How to access the values stored in HttpContext/Session while working with the ASP.NET HTML5 Document Viewer and End-User Report Designer controls

Hi Benjamin,

Thank you for sharing your solution with us. Yes, this solution is absolutely correct for ASP.NET Core projects that use DevExpress components of version 19.1.5+. Earlier versions of our ASP.NET Core reporting components do not support the dependency injection for the report storage.

I came across this topic while I was attempting to achieve a similar functional requirement - our Report Designer managed additional state (in our case, a "tenant" who owned the report design) which needed to be passed to the server during save.

I discussed a similar concern here, which was geared more at the GetUrls method of the ReportStorageWebExtension, where I came up with a different solution (injecting custom header information into every DevExpress HTTP request)
https://supportcenter.devexpress.com/ticket/details/t348757

This topic was originally raised about 5 years ago here:
https://supportcenter.devexpress.com/ticket/details/t440064

And it has been superseded by this current topic you are reading now - which is not really the same - as it's talking about using server session state to achieve these needs.
Unfortunately, introducing statefulness to an application server is a heavy-handed solution, and massive architectural change, which comes with some undesirable side-affects, impacting the entire application.

I have devised a better solution, and I'm surprised the DX support guys haven's suggested this.
(I tried and failed to get this solution to work the first time around, hence my alternate solutions, but I have just recently gotten it to work, so here it is).

XtraReport has an Extensions property, which is a key value dictionary, allowing users to store and retrieve any values they like.
Because the ReportStorageWebExtension.SetData and ReportStorageWebExtension.SetNewData methods both receive the XtraReport, you technically have the ability to pass numerous arguments, serialized as strings.

Here is an example of how to achieve this, in high-level Angular TS and C# code.

On the client, register a handler for 'ReportSaving', and use it to inject your custom arguments - technically because they are persisted in the report state for the duration of the designer session - you could inject them at any point, it doesn't have to be 'last minute' like I've done for demonstration purposes here.

HTML
<dx-report-designer #designer height="1024px">
    <dxrd-callbacks (ReportSaving)="OnReportSaving($event.args.Report, $event.args.Url, $event.component)">
    </dxrd-callbacks>
</dx-report-designer>

TypeScript
/// Helper method to add custom parameters to the report's extensions dictionary
setExtensionValue(reportViewModel: ReportViewModel, key: string, value: string) {
    var existing = ko.utils.arrayFirst(reportViewModel.extensions(), (x) => x.key() == key);
    if (existing)
        reportViewModel.extensions.remove(existing);

    var newDataSerializer = new ExtensionModel({});
    newDataSerializer.key = ko.observable(key);
    newDataSerializer.value = ko.observable(value);
    reportViewModel.extensions.push(newDataSerializer);
}

OnReportSaving(reportViewModel: ReportViewModel, url: string, component: DxReportDesignerComponent) {
    this.setExtensionValue(reportViewModel, 'MyCustomArgument', 'AnythingYouLike');
}

C#
public class CustomReportStorageWebExtension : ReportStorageWebExtension {
    /// <summary>
    /// Helper to extract a mandatory value from an XtraReport Extensions dictionary
    /// </summary>
    private T GetExtensionValue<T>(XtraReport report, string key)
    {
        string stringValue = null;

        if (report.Extensions.TryGetValue(key, out stringValue))
        {
            var converter = TypeDescriptor.GetConverter(typeof(T));
            return (T)converter.ConvertFromString(stringValue);
        }

        return default(T);
    }

    /// <summary>
    /// Helper to extract an optional value from an XtraReport Extensions dictionary
    /// </summary>
    private Nullable<T> GetNullableExtensionValue<T>(XtraReport report, string key) where T : struct
    {
        if (report.Extensions.ContainsKey(key))
            return new Nullable<T>(GetExtensionValue<T>(report, key));
        return default(Nullable<T>);
    }

    public override void SetData(XtraReport report, string url)
    {
        // grab your custom argument
        var myCustomArgument = GetNullableExtensionValue<string>(report, "MyCustomArgument");
        // ...do whatever custom logic you like with it...

        // clear the extensions to ensure custom argument is not persisted (unless you want it to be?)
        report.Extensions.Clear();

        SaveToSql(report);
    }
}

Remember that your custom extensions are embedded in the report, so they will be persisted on the server unless you remove them from the XtraReport.Extensions dictionary before sending them off to disk/sql etc.

Happy coding!

Hello,

Thank you for sharing your solution with us. However, I would like to warn you that the Extensions property is intended to serialize custom objects (e.g. services, data types, etc.) along with the report. So, the report tries to load object by using the values that are stored in this property. Thus, using this collection for storing key-value pairs may lead to unexpected behavior or even exceptions, as this collection was not intended to be used in this way.

At the same time, you can use other properties for embedding this information into a report. For example you can use the report's Tag property or even its parameters for this purpose. But I do not recommend you to store any secure data (e.g. the tenant ID) in the report. This is because the report is passed to client and back to the sever, so the attacker may get access to this information and change it.

Finally, I would like to mention that in ASP.NET Core applications all reporting services support dependency injection. So, you can inject desired services to the reporting services what will help you to get some user-related data (e.g. the tenant ID).