diff --git a/packages/devextreme/js/aspnet.js b/packages/devextreme/js/aspnet.js
index da464425f726..ce8cd815d06d 100644
--- a/packages/devextreme/js/aspnet.js
+++ b/packages/devextreme/js/aspnet.js
@@ -5,14 +5,15 @@
         define(function(require, exports, module) {
             module.exports = factory(
                 require('jquery'),
-                require('./core/templates/template_engine_registry').setTemplateEngine,
+                require('./core/templates/template_engine_registry')
+                    .setTemplateEngine,
                 require('./core/templates/template_base').renderedCallbacks,
                 require('./core/guid'),
                 require('./ui/validation_engine'),
                 require('./core/utils/iterator'),
                 require('./core/utils/dom').extractTemplateMarkup,
                 require('./core/utils/string').encodeHtml,
-                require('./core/utils/ajax')
+                require('./core/utils/ajax'),
             );
         });
     } else {
@@ -25,238 +26,398 @@
             DevExpress.utils.iterator,
             DevExpress.utils.dom.extractTemplateMarkup,
             DevExpress.utils.string.encodeHtml,
-            DevExpress.utils.ajax
+            DevExpress.utils.ajax,
         );
     }
-})(function($, setTemplateEngine, templateRendered, Guid, validationEngine, iteratorUtils, extractTemplateMarkup, encodeHtml, ajax) {
-    var templateCompiler = createTemplateCompiler();
-    var pendingCreateComponentRoutines = [ ];
+})(
+    function(
+        $,
+        setTemplateEngine,
+        templateRendered,
+        Guid,
+        validationEngine,
+        iteratorUtils,
+        extractTemplateMarkup,
+        encodeHtml,
+        ajax,
+    ) {
+        var templateCompiler = createTemplateCompiler();
+        var pendingCreateComponentRoutines = [];
+        // csp handling mode marker: detect | once | csp_only | legacy
+        var cspHandlingMode = setCspHandlingMode();
+        var cspRestricted = null;
 
-    function createTemplateCompiler() {
-        var ENCODE_QUALIFIER = '-',
-            INTERPOLATE_QUALIFIER = '=';
+        // eslint-disable-next-line no-console
+        console.log('csp handling mode: ' + cspHandlingMode);
 
-        var EXTENDED_OPEN_TAG = /[<[]%/g,
-            EXTENDED_CLOSE_TAG = /%[>\]]/g;
+        function setCspHandlingMode() {
+            const metaCSPMode = window.document.querySelector(
+                'meta[name="dx-csp-handling-mode"]',
+            )?.content;
+            return metaCSPMode || 'legacy';
+        }
 
-        function acceptText(bag, text) {
-            if(text) {
-                bag.push('_.push(', JSON.stringify(text), ');');
+        function readCspDirective(csp, name) {
+            var directives = csp.split(';');
+            for(var i = 0; i < directives.length; i++) {
+                var parts = directives[i].trim().split(/\s+/);
+                if(parts.length && parts[0].toLowerCase() === name) {
+                    return parts.slice(1).join(' ').toLowerCase();
+                }
             }
+            return null;
         }
 
-        function acceptCode(bag, code) {
-            var encode = code.charAt(0) === ENCODE_QUALIFIER,
-                value = code.substr(1),
-                interpolate = code.charAt(0) === INTERPOLATE_QUALIFIER;
-
-            if(encode || interpolate) {
-                bag.push('_.push(');
-                var expression = value;
-                if(encode) {
-                    expression = 'encodeHtml((' + value + ' !== null && ' + value + ' !== undefined) ? ' + value + ' : "")';
-                    if(/^\s*$/.test(value)) {
-                        expression = 'encodeHtml(' + value + ')';
-                    }
+        function canUseFunctionConstructor() {
+            var isFunctionConstructorAllowed = false;
+            try {
+                // eslint-disable-next-line no-new-func
+                new Function('return true');
+                isFunctionConstructorAllowed = true;
+            } catch(e) {
+                // Content Security Policy without 'unsafe-eval' blocks the Function constructor.
+                isFunctionConstructorAllowed = false;
+            }
+            return isFunctionConstructorAllowed;
+        }
+
+        function detectCspRestricted() {
+            var doc = window.document;
+            var scripts = doc.getElementsByTagName('script');
+            for(var i = 0; i < scripts.length; i++) {
+                if(scripts[i].nonce || scripts[i].getAttribute('nonce')) {
+                    return true;
+                }
+            }
+            var meta = doc.querySelectorAll(
+                'meta[http-equiv=\'Content-Security-Policy\' i]',
+            );
+            for(var j = 0; j < meta.length; j++) {
+                var content = meta[j].getAttribute('content') || '';
+                var directive = readCspDirective(content, 'script-src');
+                if(null === directive) {
+                    directive = readCspDirective(content, 'default-src');
+                }
+                if(
+                    null !== directive &&
+                    -1 === directive.indexOf('\'unsafe-eval\'')
+                ) {
+                    return true;
                 }
-                bag.push(expression);
-                bag.push(');');
-            } else {
-                bag.push(code + '\n');
             }
+            return false;
+        }
+
+        function isCspRestricted() {
+            if(cspRestricted !== null) {
+                return cspRestricted;
+            }
+            switch(cspHandlingMode) {
+                case 'detect':
+                    cspRestricted = detectCspRestricted();
+                    break;
+                case 'csp_only':
+                    cspRestricted = true;
+                    break;
+                case 'once':
+                    cspRestricted = !canUseFunctionConstructor();
+                    break;
+                case 'legacy':
+                default:
+                    cspRestricted = false;
+            }
+            return cspRestricted;
+        }
+
+        function compileViaScript(src, code) {
+            if(!src || src.tagName !== 'SCRIPT') {
+                return null;
+            }
+            if(isCspRestricted() && !src.nonce) {
+                // eslint-disable-next-line no-console
+                console.warn(
+                    'DevExtreme: template <script> #' +
+                        src.id +
+                        ' has no nonce; the compiled script may be blocked by CSP.',
+                );
+            }
+            var funcName = src.id.replaceAll('-', '');
+            var func =
+                'function ' + funcName + '(obj,encodeHtml){\n' + code + '\n}';
+            $.globalEval(func, src, window.document);
+            return funcName;
         }
 
-        return function(element) {
-            var text = extractTemplateMarkup(element);
-            var bag = ['var _ = [];', 'with(obj||{}) {'],
-                chunks = text.split(EXTENDED_OPEN_TAG);
 
-            acceptText(bag, chunks.shift());
+        function createTemplateCompiler() {
+            var ENCODE_QUALIFIER = '-',
+                INTERPOLATE_QUALIFIER = '=';
 
-            for(var i = 0; i < chunks.length; i++) {
-                var tmp = chunks[i].split(EXTENDED_CLOSE_TAG);
-                if(tmp.length !== 2) {
-                    throw 'Template syntax error';
+            var EXTENDED_OPEN_TAG = /[<[]%/g,
+                EXTENDED_CLOSE_TAG = /%[>\]]/g;
+
+            function acceptText(bag, text) {
+                if(text) {
+                    bag.push('_.push(', JSON.stringify(text), ');');
                 }
-                acceptCode(bag, tmp[0]);
-                acceptText(bag, tmp[1]);
             }
 
-            bag.push('}', 'return _.join(\'\')');
-            var code = bag.join('');
+            function acceptCode(bag, code) {
+                var encode = code.charAt(0) === ENCODE_QUALIFIER,
+                    value = code.substr(1),
+                    interpolate = code.charAt(0) === INTERPOLATE_QUALIFIER;
 
-            try {
-                // eslint-disable-next-line no-new-func
-                return new Function('obj', 'encodeHtml', code);
-            } catch(e) {
-                var src = element[0];
-                if(src.tagName === 'SCRIPT') {
-                    var funcName = src.id.replaceAll('-', '');
-                    var func = 'function ' + funcName + '(obj,encodeHtml){\n' + code + '\n}';
-                    $.globalEval(func, src, window.document);
-                    return funcName;
+                if(encode || interpolate) {
+                    bag.push('_.push(');
+                    var expression = value;
+                    if(encode) {
+                        expression =
+                            'encodeHtml((' +
+                            value +
+                            ' !== null && ' +
+                            value +
+                            ' !== undefined) ? ' +
+                            value +
+                            ' : "")';
+                        if(/^\s*$/.test(value)) {
+                            expression = 'encodeHtml(' + value + ')';
+                        }
+                    }
+                    bag.push(expression);
+                    bag.push(');');
                 } else {
-                    return text;
+                    bag.push(code + '\n');
                 }
             }
-        };
-    }
 
-    function createTemplateEngine() {
-        return {
-            compile: function(element) {
-                return templateCompiler(element);
-            },
-            render: function(template, data) {
-                if(template instanceof Function) {
-                    var html = template(data, encodeHtml);
+            return function(element) {
+                var text = extractTemplateMarkup(element);
+                var bag = ['var _ = [];', 'with(obj||{}) {'],
+                    chunks = text.split(EXTENDED_OPEN_TAG);
+
+                acceptText(bag, chunks.shift());
 
-                    var dxMvcExtensionsObj = window['MVCx'];
-                    if(dxMvcExtensionsObj && !dxMvcExtensionsObj.isDXScriptInitializedOnLoad) {
-                        html = html.replace(/(<script[^>]+)id="dxss_.+?"/g, '$1');
+                for(var i = 0; i < chunks.length; i++) {
+                    var tmp = chunks[i].split(EXTENDED_CLOSE_TAG);
+                    if(tmp.length !== 2) {
+                        throw 'Template syntax error';
                     }
+                    acceptCode(bag, tmp[0]);
+                    acceptText(bag, tmp[1]);
+                }
 
-                    return html;
-                } else if(window[template] instanceof Function) {
-                    return window[template](data, encodeHtml);
-                } else if(typeof template === 'string') {
-                    return template;
-                } else {
-                    throw 'Unknown template type';
+                bag.push('}', 'return _.join(\'\')');
+                var code = bag.join('');
+                var src = element[0];
+
+                // with csp_only mode, we always compile via script, and if it fails, we fallback to the text template
+                if(isCspRestricted()) {
+                    // might be extracted to a separate function
+                    var compiled = compileViaScript(src, code);
+                    return compiled !== null ? compiled : text;
                 }
-            }
-        };
-    }
 
-    function getValidationSummary(validationGroup) {
-        var result;
-        $('.dx-validationsummary').each(function(_, element) {
-            var summary = $(element).data('dxValidationSummary');
-            if(summary && summary.option('validationGroup') === validationGroup) {
-                result = summary;
-                return false;
-            }
-        });
-        return result;
-    }
+                // fallback to old behavior for legacy mode, or if Function constructor is allowed
+                try {
+                    // eslint-disable-next-line no-new-func
+                    return new Function('obj', 'encodeHtml', code);
+                } catch(e) {
+                    var compiled = compileViaScript(src, code);
+                    return compiled !== null ? compiled : text;
+                }
+            };
+        }
 
-    function createValidationSummaryItemsFromValidators(validators, editorNames) {
-        var items = [];
+        function createTemplateEngine() {
+            return {
+                compile: function(element) {
+                    return templateCompiler(element);
+                },
+                render: function(template, data) {
+                    if(template instanceof Function) {
+                        var html = template(data, encodeHtml);
 
-        iteratorUtils.each(validators, function(_, validator) {
-            var widget = validator.$element().data('dx-validation-target');
-            if(widget && $.inArray(widget.option('name'), editorNames) > -1) {
-                items.push({
-                    text: widget.option('validationError.message'),
-                    validator: validator
-                });
-            }
-        });
+                        var dxMvcExtensionsObj = window['MVCx'];
+                        if(
+                            dxMvcExtensionsObj &&
+                            !dxMvcExtensionsObj.isDXScriptInitializedOnLoad
+                        ) {
+                            html = html.replace(
+                                /(<script[^>]+)id="dxss_.+?"/g,
+                                '$1',
+                            );
+                        }
 
-        return items;
-    }
+                        return html;
+                    } else if(window[template] instanceof Function) {
+                        return window[template](data, encodeHtml);
+                    } else if(typeof template === 'string') {
+                        return template;
+                    } else {
+                        throw 'Unknown template type';
+                    }
+                },
+            };
+        }
 
-    function createComponent(name, options, id, validatorOptions) {
-        var selector = '#' + String(id).replace(/[^\w-]/g, '\\$&');
-        pendingCreateComponentRoutines.push(function() {
-            var $element = $(selector);
-            if($element.length) {
-                var $component = $(selector)[name](options);
-                if($.isPlainObject(validatorOptions)) {
-                    $component.dxValidator(validatorOptions);
+        function getValidationSummary(validationGroup) {
+            var result;
+            $('.dx-validationsummary').each(function(_, element) {
+                var summary = $(element).data('dxValidationSummary');
+                if(
+                    summary &&
+                    summary.option('validationGroup') === validationGroup
+                ) {
+                    result = summary;
+                    return false;
                 }
-                return true;
-            }
-            return false;
-        });
-    }
+            });
+            return result;
+        }
 
-    templateRendered.add(function() {
-        var snapshot = pendingCreateComponentRoutines.slice();
-        var leftover = [ ];
+        function createValidationSummaryItemsFromValidators(
+            validators,
+            editorNames,
+        ) {
+            var items = [];
 
-        pendingCreateComponentRoutines = [ ];
-        snapshot.forEach(function(func) {
-            if(!func()) {
-                leftover.push(func);
-            }
+            iteratorUtils.each(validators, function(_, validator) {
+                var widget = validator.$element().data('dx-validation-target');
+                if(
+                    widget &&
+                    $.inArray(widget.option('name'), editorNames) > -1
+                ) {
+                    items.push({
+                        text: widget.option('validationError.message'),
+                        validator: validator,
+                    });
+                }
+            });
+
+            return items;
+        }
+
+        function createComponent(name, options, id, validatorOptions) {
+            var selector = '#' + String(id).replace(/[^\w-]/g, '\\$&');
+            pendingCreateComponentRoutines.push(function() {
+                var $element = $(selector);
+                if($element.length) {
+                    var $component = $(selector)[name](options);
+                    if($.isPlainObject(validatorOptions)) {
+                        $component.dxValidator(validatorOptions);
+                    }
+                    return true;
+                }
+                return false;
+            });
+        }
+
+        templateRendered.add(function() {
+            var snapshot = pendingCreateComponentRoutines.slice();
+            var leftover = [];
+
+            pendingCreateComponentRoutines = [];
+            snapshot.forEach(function(func) {
+                if(!func()) {
+                    leftover.push(func);
+                }
+            });
+            pendingCreateComponentRoutines =
+                pendingCreateComponentRoutines.concat(leftover);
         });
-        pendingCreateComponentRoutines = pendingCreateComponentRoutines.concat(leftover);
-    });
-
-    return {
-        createComponent: createComponent,
-
-        renderComponent: function(name, options, id, validatorOptions) {
-            id = id || ('dx-' + new Guid());
-            createComponent(name, options, id, validatorOptions);
-            return '<div id="' + id + '"></div>';
-        },
-
-        getEditorValue: function(inputName) {
-            var $widget = $('input[name=\'' + inputName + '\']').closest('.dx-widget');
-            if($widget.length) {
-                var dxComponents = $widget.data('dxComponents'),
-                    widget = $widget.data(dxComponents[0]);
-
-                if(widget) {
-                    return widget.option('value');
+
+        return {
+            createComponent: createComponent,
+
+            renderComponent: function(name, options, id, validatorOptions) {
+                id = id || 'dx-' + new Guid();
+                createComponent(name, options, id, validatorOptions);
+                return '<div id="' + id + '"></div>';
+            },
+
+            getEditorValue: function(inputName) {
+                var $widget = $('input[name=\'' + inputName + '\']').closest(
+                    '.dx-widget',
+                );
+                if($widget.length) {
+                    var dxComponents = $widget.data('dxComponents'),
+                        widget = $widget.data(dxComponents[0]);
+
+                    if(widget) {
+                        return widget.option('value');
+                    }
                 }
-            }
-        },
+            },
 
-        setTemplateEngine: function() {
-            if(setTemplateEngine) {
-                setTemplateEngine(createTemplateEngine());
-            }
-        },
-
-        createValidationSummaryItems: function(validationGroup, editorNames) {
-            var summary = getValidationSummary(validationGroup),
-                groupConfig,
-                items;
-
-            if(summary) {
-                groupConfig = validationEngine.getGroupConfig(validationGroup);
-                if(groupConfig) {
-                    items = createValidationSummaryItemsFromValidators(groupConfig.validators, editorNames);
-                    items.length && summary.option('items', items);
+            setTemplateEngine: function() {
+                if(setTemplateEngine) {
+                    setTemplateEngine(createTemplateEngine());
                 }
-            }
-        },
-
-        sendValidationRequest: function(propertyName, params, url, method, additionalFields) {
-            var d = $.Deferred();
-            var data = { };
-            data[propertyName] = params.value;
-            if(additionalFields.length && params.data) {
-                additionalFields.forEach(function(field) {
-                    data[field] = params.data[field];
-                });
-            }
+            },
+
+            createValidationSummaryItems: function(
+                validationGroup,
+                editorNames,
+            ) {
+                var summary = getValidationSummary(validationGroup),
+                    groupConfig,
+                    items;
+
+                if(summary) {
+                    groupConfig =
+                        validationEngine.getGroupConfig(validationGroup);
+                    if(groupConfig) {
+                        items = createValidationSummaryItemsFromValidators(
+                            groupConfig.validators,
+                            editorNames,
+                        );
+                        items.length && summary.option('items', items);
+                    }
+                }
+            },
 
-            ajax.sendRequest({
-                url: url,
-                dataType: 'json',
-                method: method || 'GET',
-                data: data
-            }).then(function(response) {
-                if(typeof response === 'string') {
-                    d.resolve({
-                        isValid: false,
-                        message: response
+            sendValidationRequest: function(
+                propertyName,
+                params,
+                url,
+                method,
+                additionalFields,
+            ) {
+                var d = $.Deferred();
+                var data = {};
+                data[propertyName] = params.value;
+                if(additionalFields.length && params.data) {
+                    additionalFields.forEach(function(field) {
+                        data[field] = params.data[field];
                     });
-                } else {
-                    d.resolve(response);
                 }
-            }, function(xhr) {
-                d.reject({
-                    isValid: false,
-                    message: xhr.responseText
-                });
-            });
 
-            return d.promise();
-        }
-    };
-});
+                ajax.sendRequest({
+                    url: url,
+                    dataType: 'json',
+                    method: method || 'GET',
+                    data: data,
+                }).then(
+                    function(response) {
+                        if(typeof response === 'string') {
+                            d.resolve({
+                                isValid: false,
+                                message: response,
+                            });
+                        } else {
+                            d.resolve(response);
+                        }
+                    },
+                    function(xhr) {
+                        d.reject({
+                            isValid: false,
+                            message: xhr.responseText,
+                        });
+                    },
+                );
+
+                return d.promise();
+            },
+        };
+    },
+);