U2U Blog

U2U Online V2.1 is here!

Tue, 13 Jun 2023 10:29:00 +0000

This blog post explains the latest features present in the most recent version of our online platform, online.u2u.be, which we, as trainers, fondly refer to as 'U2U Online'. In case you are unfamiliar with U2U Online, it is likely that you have not attended any of our training courses, as that is where the true magic happens.

U2U Online serves as our in-house online learning platform, granting our students access to all the necessary materials linked to their ongoing trainings. This includes theoretical resources, practical exercises, videos, references, general information, and even a group chat to communicate with each other. By exhibiting all these resources in a centralized location, we strive to ensure an optimal user-friendly experience for our students.

To provide context, it is crucial to understand the rationale behind the online learning platform. Have you ever encountered the Learning Pyramid Model? This model explains various modes of learning and assesses their efficacy in retaining knowledge. Notably, the model differentiates between passive and active learning methods, with the latter exhibiting a higher rate of knowledge retention compared to the former.

Figure 1: Learning Pyramid : https://www.arlo.co/blog/overview-of-the-learning-pyramid-for-training-providers

While it is imperative to incorporate active learning methods, it is equally important not to disregard the passive learning techniques. A well-rounded training program entails a balance between the two. At U2U, we have carefully combined passive and active learning methods to optimize the learning retention for our students.

Merely providing demonstrations may facilitate a 30 percent recall of the theory, but this alone does not suffice. Therefore, we complement our approach with active learning methods. For instance, we initiate classroom discussions by encouraging participants to share their existing knowledge on the subject matter or by posing thought-provoking questions such as 'What do you think will happen and can you explain why?'.

Furthermore, students are provided ample time to engage in detailed exercises that allow them to put the theory into practice, resulting in a remarkable 75 percent retention rate. As such, it is crucial for us to prioritize a seamless user experience including both theoretical and practical aspects. To this end, we have strived to optimize the user experience by developing and improving our online learning platform, U2U Online.

It has been a few weeks since the implementation of U2U Online V2.1. As is customary with any software program or product, we conducted thorough testing to rectify any remaining minor bugs before unrolling it to the wider audience. Those initial challenges are now behind us, and on behalf of the entire U2U team, Now that those initial challenges are behind us, the entire U2U team is delighted and proud of the result. That's why I'm writing this blog post to walk you through the major differences between V2.0 and V2.1, along with the exciting new features.

Separation of Theory and Labs

Each of our courses consist of modules including both theoretical and practical components. The theory portion involves PowerPoint slides, while the lab segment involves hands-on exercises corresponding to the recently acquired knowledge. In the previous version of U2U Online, theory and labs were combined into a single Word document with numerous pages, requiring considerable scrolling to locate the exercises.

In the newest iteration of U2U Online, we have divided each module into distinct theory and lab sections. Bid farewell to the arduous task of searching for exercise starting points within lengthy documents! Within each module, theory and lab materials are elegantly displayed side by side, facilitating seamless transition between theory and practical applications. Thus, we have successfully resolved Issue 1.

Figure 2: Side by Side rendered Theory and Labs

Enhanced Rendering of Theory Presentations

In U2U Online V2.0, the theory portion of each module comprised screenshots of PowerPoint slides, arranged in a web layout with two slides per page. This approach presented several challenges, such as the inability to click on hyperlinks, copy-paste text, or navigate through subsections smoothly.

Figure 3: Theory rendering in V2.0 (old)

To rectify these limitations, we now render each slide individually in the new version of U2U Online. Moreover, we have incorporated a subsection navigator on the left-hand side for effortless navigation to specific subsections as needed. With this direct slide rendering approach, interactive features such as hyperlink functionality and text copying are fully enabled.

Figure 4: Theory rendering in V2.1 (new) Enhanced Rendering of Labs

Enhanced Rendering of Labs

Similar to the theory portion, labs were previously rendered within a single Word document comprising multiple pages. Each lab typically encompassed multiple exercises belonging to different subsections, without the ability to navigate between them easily. While it was possible to interact with the text, such as copying specific code snippets, the discrepancy between Word and the rendering engine introduced frustrations in selecting specific text regions.

Figure 5: Lab rendering in V2.0 (old)

To address these issues, we now directly render labs within the U2U Online platform, eliminating the need for Word as an intermediate source. We employ Markdown to visualize text, images, and code snippets in a clear format. This approach empowers end-users to interact effortlessly with the exercise materials. Text automatically scales in relation to the available screen space, and each lab subsection is presented as a separate scrollable page, ensuring a coherent visualization of all associated steps. Furthermore, the section navigator allows swift navigation between sections when necessary.

Additionally, lab files associated with a given exercise, such as starter files, resources, and solutions, previously required users to navigate back to the menu, download the files, and then manually find their place in the exercise again. To mitigate this inconvenience, we have incorporated a solution in the new version. At the top of the Section Navigator, users can now directly download lab files associated with the current exercise, eliminating the need to leave the page or lose track of progress. All necessary resources are conveniently accessible from within the current page.

Figure 6: Rendering Labs in V2.1 (new)

Streamlined Evaluations

At the conclusion of each training course, we kindly request that students complete an evaluation form. This valuable feedback allows us to continually enhance our course materials and ensure alignment with student expectations. As a token of appreciation for completing the evaluation, students are granted access to a digital certificate for their course participation.

In U2U Online V2.0, students had to click a link within the course to be redirected to an external webpage for evaluation submission. After completing the evaluation, they needed to manually return to U2U Online to download their certificate, potentially sharing it on social media or saving it as a PDF. However, in U2U Online V2.1, we have integrated the entire evaluation process within the platform itself. There is no longer a need for redirection or returning to U2U Online after submitting the evaluation. The entire process is now centralized.

Figure 7: Evaluations included in V2.1 (new)

Figure 8: Integrated sharing of the obtained certificate in V2.1 (new)

These four improvements constitute the most significant enhancements in U2U Online V2.1. If you haven't explored these features yet, I highly recommend taking a look and experiencing them firsthand. Of course, there is always room for further improvements, and we are actively working on designing V2.2 with additional features that will prove advantageous. Stay tuned for updates on these new features and their anticipated release date.

Using the Power Platform CLI with Power Pages

Thu, 30 Mar 2023 11:17:00 +0000

In this blog post you will see how to use the Power Platform CLI with Power Pages. This feature enables you to download the content of a Power Pages site and edit it in Visual Studio Code. Once finished, you can upload all your changes back to the Power Pages site. Another use case for this feature is to move a Power Pages site between production, acceptance and production environments.

As a first step you will need to install and download Visual Studio Code. Once installed you can follow the steps below to install the Power Platform CLI.

Start Visual Studio Code.
Select the Extensions icon from the left-side window.

In the search text box, type Power Platform Tools.

Click the on the blue Install button.
Restart Visual Studio Code.

Once Visual Studio Code is restarted, go to View -> Terminal to open a new Terminal window. In this new terminal window type pac and press enter.

This will list all the commands that can be executed using the Power Platform CLI.

As a first step, we must authenticate with the Dataverse environment that hosts the Power Pages site for which we want to download the content. For this we can run the pac auth create --environment [Dataverse Environment URL] command.

pac auth create --environment https://u2udev.crm4.dynamics.com

Once you successfully login, the following output will be displayed.

'trainer@u2ucourse.com' authenticated successfully.
Validating connection...
Default organization: U2UDev
Authentication profile created
    * UNIVERSAL                                https://u2udev.crm4.dynamics.com/        : trainer@u2ucourse.com                    Public

If you now want to list all Power Pages sites in the selected environment, you can use the pac paportal list command. As you can see in the output below, there are 2 Power Pages sites present in the selected environment.

PS /Users/jurgenpostelmans> pac paportal list
Connected to... U2UDev
Connected as trainer@u2ucourse.com

Completed listing Power Pages websites

 Index      Website Id                                         Friendly Name                                               

 [1]        fd99279d-cace-ed11-b597-0022489ee5d6               U2U Blog Post - u2ublogpost                                 
 [2]        ad7c0439-f381-ed11-81ad-0022489fd57f               U2U Portal - u2uportal

To download the content of a Power Pages site, you can use the pac paportal download --path [Local Path] --webSiteId [WebSiteId-GUID] command. The path parameter indicates where the Power Pages website content will be downloaded. The WebSiteId-GUID is the ID of the Power Pages site and can be found in the output of the pac paportal list command above.

PS /Users/jurgenpostelmans/blogpost> pac paportal download --path ./ --webSiteId fd99279d-cace-ed11-b597-0022489ee5d6


Information:
Be careful when you're updating public sites. The changes you make are visible to anyone immediately. To check site visibility go to https://make.powerpages.microsoft.com/.
To get additional information, please visit https://go.microsoft.com/fwlink/?linkid=2204350


Started downloading website fd99279d-cace-ed11-b597-0022489ee5d6
Connected to... U2UDev
Connected as trainer@u2ucourse.com
Downloading: Website [adx_website]...
Downloaded: Website [adx_website]
Downloading: Website Language [adx_websitelanguage]...
...
Updating manifest...
Manifest updated successfully.
Power Pages website download succeeded in 13.465261 secs.

Once the download is finished, a new folder is created that is made up of the display name and name of your Power Pages site.

PS /Users/jurgenpostelmans/blogpost> ls -l
total 0
drwxr-xr-x@ 25 jurgenpostelmans  staff  800 Mar 30 10:58 u2u-blog-post---u2ublogpost
PS /Users/jurgenpostelmans/blogpost>

Open this folder with Visual Studio Code.

If we now want to edit the content of the Home page, open the file that is named Home.en-US.webpage.copy.html.

Let's add some custom text and a small piece of Liquid code inside the innermost div tag.

<div class='row sectionBlockLayout text-left' style='display: flex; flex-wrap: wrap; margin: 0px; min-height: auto; padding: 8px;'>
  <div class='container' style='padding: 0px; display: flex; flex-wrap: wrap;'>
    <div class='col-md-12 columnBlockLayout' style='flex-grow: 1; display: flex; flex-direction: column; min-width: 300px;'>
      This page was modified in Visual Studio Code<br>
      {{ now }}
    </div>
  </div>
</div>

To upload the changes, the pac paportal upload --path [Local Path] command can be used.

PS /Users/jurgenpostelmans/blogpost/u2u-blog-post---u2ublogpost> pac paportal upload --path ./                                                   


Information:
Be careful when you're updating public sites. The changes you make are visible to anyone immediately. To check site visibility go to https://make.powerpages.microsoft.com/.
To get additional information, please visit https://go.microsoft.com/fwlink/?linkid=2204350


Started uploading website data
Connected to... U2UDev
Connected as trainer@u2ucourse.com

Loading Power Pages website manifest...

Manifest loaded successfully.

Updated record(s) for table: adx_webpage

Power Pages website upload succeeded in 5.77 secs.

Notice how it only uploads data for the adx_webpage entity because the command only uploads new/modified/deleted content. When the content of a Power Pages site is download, a manifest.yaml file is created inside the .portalconfig folder.

As you can see in the screenshot, a checksum is calculated and stored for each record that was downloaded. If the content of a record gets modified, the current checksum will not match with the checksum in the manifest. This way the pac paportal upload command can upload only the changes.

SharePoint Column Formatting - Rounded images

Wed, 20 Feb 2019 17:52:00 +0000

Is recently had the need to show a picture column in a SharePoint list as a Persona element as provided in the Office UI Fabric. Now if it came down to it, it was just enough to have an image with a border radius, and not all the other mumbo jumbo from Persona.

The result looks as follows:

The json to put in the column formatting pane:

{
    "$schema": "https://developer.microsoft.com/json-schemas/sp/column-formatting.schema.json",
    "elmType": "div",
    "children": [
        {
            "elmType": "img",
            "attributes": {
                "src": "@currentField"
            },
            "style": {
                "width": "100px",
                "border-radius": "50%"
            }
        }
    ]
}

Using out of the box web parts as Tabs in Teams

Fri, 30 Nov 2018 11:43:00 +0000

This blog post is a follow-up on the session we gave at the European SharePoint Conference. In this session I demonstrated how you can take your custom SPFx web parts and make them available in Microsoft Teams as a configurable tab.

This functionality was introduced in SPFx 1.7 in Preview. Now, how SPFx makes this possible, is by adding a Teams manifest to your project that contains the configurable tabs. It looks as follows:

...
"configurableTabs": [
    {
      "configurationUrl": "https://{teamSiteDomain}{teamSitePath}/_layouts/15/TeamsLogon.aspx?SPFX=true&dest={teamSitePath}/_layouts/15/teamshostedapp.aspx%3FopenPropertyPane=true%26teams%26componentId=be78544a-3fbf-466e-aadb-41bac5a984f0",
      "canUpdateConfiguration": false,
      "scopes": [
        "team"
      ]
    }
  ],
...

In the segment above, observe that the magic is handled by 2 new application pages in SharePoint:

TeamsLogon.aspx: this page will make sure the user is logged into SharePoint, which is needed since Teams and SharePoint run in different domains
TeamsHostedApp.aspx: this page will do all the magic of configuring and loading your web part into a page

The TeamsHostedApp.aspx contains a reference to the componentId, this is the ID of your web part which you can find in the web part manifest. This got me thinking, if SharePoint uses SPFx to build their own web parts, then it should also be possible to use this approach on the out of the box client side web parts?

So just find the web part you are interested in using the REST api

GET /_api/web/GetClientSideWebParts

I'm actually very interested in the Highlighted Content web part:

{
  "value": [
    {
      "ComponentType": 1,
      "Id": "**daf0b71c-6de8-4ef7-b511-faae7c388708**",
      "Manifest": "{\"preconfiguredEntries\":[{\"title\":{\"default\":\"Highlighted content\",\"ar-SA\":\"المحتوى المميز\",\"az-Latn-AZ\":\"Vurğulanmış məzmun\",\"bg-BG\":\"Акцентирано съдържание\"
...

Using the same Teams manifest, we can now alter it to our liking, making sure we provide a unique Id and replace the componentId to the one from the Highlighted Content web part. Below is the full manifest.

{
  "$schema": "https://developer.microsoft.com/en-us/json-schemas/teams/v1.2/MicrosoftTeams.schema.json",
  "manifestVersion": "1.2",
  "packageName": "HighlightedContent",
  "id": "be78544a-3fbf-466e-aadb-41bac5a984f3",
  "version": "0.1",
  "developer": {
    "name": "SPFx + Teams Dev",
    "websiteUrl": "https://products.office.com/en-us/sharepoint/collaboration",
    "privacyUrl": "https://privacy.microsoft.com/en-us/privacystatement",
    "termsOfUseUrl": "https://www.microsoft.com/en-us/servicesagreement"
  },
  "name": {
    "short": "Highlighted Content"
  },
  "description": {
    "short": "Highlighted Content",
    "full": "Highlighted Content"
  },
  "icons": {
    "outline": "tab20x20.png",
    "color": "tab96x96.png"
  },
  "accentColor": "#004578",
  "configurableTabs": [
    {
      "configurationUrl": "https://{teamSiteDomain}{teamSitePath}/_layouts/15/TeamsLogon.aspx?SPFX=true&dest={teamSitePath}/_layouts/15/teamshostedapp.aspx%3FopenPropertyPane=true%26teams%26componentId=daf0b71c-6de8-4ef7-b511-faae7c388708",
      "canUpdateConfiguration": false,
      "scopes": [
        "team"
      ]
    }
  ],
  "validDomains": [
    "*.login.microsoftonline.com",
    "*.sharepoint.com",
    "*.sharepoint-df.com",
    "spoppe-a.akamaihd.net",
    "spoprod-a.akamaihd.net",
    "resourceseng.blob.core.windows.net",
    "msft.spoppe.com"
  ],
  "webApplicationInfo": {
    "resource": "https://{teamSiteDomain}",
    "id": "00000003-0000-0ff1-ce00-000000000000"
  }
}

Now zip the manifest together with the icons and upload to your Teams App Store. Once it is uploaded, you will be able to add it to a channel within a team. You will see the Property Pane asking you for input and finally the web part being rendered inside the newly created tab.

Only load those things you need in CSOM

Mon, 27 Aug 2018 14:49:00 +0000

This is a small post to emphasize why you should only load the things you need with Client Side Object Model for SharePoint. One of the most straightforward reasons to load only what you need is "The amount of data that goes over the wire". Yes, but what about security? If you are loading things you do not need, you might get an unwanted ServerUnauthorizedAccessException.

Consider the following code snippet that is taken from OfficeDevPnP.Core.

public static Folder EnsureFolderPath(this Web web, string webRelativeUrl, params Expression<Func<Folder, object>>[] expressions)
{
  if (webRelativeUrl == null) { throw new ArgumentNullException(nameof(webRelativeUrl)); }

  //Web root folder should be returned if webRelativeUrl is empty
  if (webRelativeUrl.Length != 0 && string.IsNullOrWhiteSpace(webRelativeUrl)) { throw new ArgumentException(CoreResources.FileFolderExtensions_EnsureFolderPath_Folder_URL_is_required_, nameof(webRelativeUrl)); }

  // Check if folder exists
  if (!web.IsPropertyAvailable("ServerRelativeUrl"))
  {
    web.Context.Load(web, w => w.ServerRelativeUrl);
    web.Context.ExecuteQueryRetry();
  }

  var folderServerRelativeUrl = UrlUtility.Combine(web.ServerRelativeUrl, webRelativeUrl, "/");

  // Check if folder is inside a list
  var listCollection = web.Lists;
  web.Context.Load(listCollection, lc => lc.Include(l => l.RootFolder));
  web.Context.ExecuteQueryRetry();

  List containingList = null;

  foreach (var list in listCollection)
  {
    if (folderServerRelativeUrl.StartsWith(UrlUtility.Combine(list.RootFolder.ServerRelativeUrl, "/"), StringComparison.InvariantCultureIgnoreCase))
    {
      // Load fields from the list
      containingList = list;
      break;
    }
  }
  ...
}

Observe that the code is loading the folder for every list, just to use the ServerRelativeUrl. When you execute this method with e.g. App-Only authentication for an app that has Manage on Site Collection. You might get a ServerUnauthorizedAccessException on the ExecuteQueryRetry, which seems kinda strange ... given the fact that the add-in has Manage permissions on Site Collection. Updating the code to only include the ServerRelativeUrl per Folder fixes this nasty Exception.

// Check if folder is inside a list
var listCollection = web.Lists;
web.Context.Load(listCollection, lc => lc.Include(l => l.RootFolder.ServerRelativeUrl));
web.Context.ExecuteQueryRetry();

Using the MSGraphClient in SPFx to return blob images

Mon, 2 Jul 2018 18:43:00 +0000

In SharePoint Framework version 1.4, they introduced the new MSGraphClient, which makes your live a lot easier when you need to call the Microsoft Graph. For reference sake, getting access to the MSGraphClient can be done as follows.

import { WebPartContext } from '@microsoft/sp-webpart-base';
import { MSGraphClient } from '@microsoft/sp-client-preview';
export class DataService implements IDataService {
  private msGraphClient: MSGraphClient;

  constructor(private context: WebPartContext) {
    this.msGraphClient = context.serviceScope.consume(MSGraphClient.serviceKey);
  }
}

When you need to call the Microsoft Graph, but the result is not a json object, but an image. Then you probably want the result as a blob. This can be achieved by using the responseType method as follows.

public GetImage(id: string): Promise<string> {
  return this.msGraphClient
    .api(`/users/${id}/photos/48x48/$value`)
    .responseType('blob')
    .get()
    .then((blob: Blob) => {
      return blob ? URL.createObjectURL(blob) : null;
    });
}

Calling the SharePoint Online API from within Microsoft Flow

Fri, 9 Feb 2018 10:21:00 +0000

In this blog post I will explain how you can call the SharePoint API from within Microsoft Flow, without having to fall back to Azure Functions, custom connector, premium connectors, ... just pure Microsoft Flow.

I still remember Microsoft Flow in the beginning, when the SharePoint connector only had 4 actions, while now it already has more than 25 actions. But this is still just a fraction of what you want to do inside your flows. All those other things like: creating a sub site, accessing the SharePoint groups, ... is not possible (yet?). But there is a powerful REST API in SharePoint available, that allows you to do everything you've ever dreamed of (in SharePoint). And Microsoft Flow has an HTTP connector which allows you to call such APIs. The only problem with that API is ... it requires authentication, like an Access Token.

Using add-in-only policy to get an access token

Now, this got me thinking ... would it be possible to use the add-in authentication inside flow to get that access token. Obviously, I'm interested in the scenario of add-in-only policy, since I have no user to authenticate. I will consider Azure AD in a later blog post. The Microsoft documentation explains how an add-in can make add-in only calls. In its essence, retrieving the access token falls back to a POST call against https://accounts.accesscontrol.windows.net/

The POST will look something like this:

POST https://accounts.accesscontrol.windows.net/REALM/tokens/OAuth/2
Content-Type: application/x-www-form-urlencoded
grant_type=client_credentials&client_id=CLIENTID@REALM&client_secret=CLIENTSECRET=&scope=00000003-0000-0ff1-ce00-000000000000/TENANT.sharepoint.com@REALM&resource=00000003-0000-0ff1-ce00-000000000000/TENANT.sharepoint.com@REALM

We just need retrieve and fill in the missing parameters:

REALM: Realm is a unique identifier assigned to your SharePoint tenant.
CLIENTID: Identifier for your add-in, obtained during registration.
CLIENTSECRET: Secret for your add-in, obtained during registration.
TENANT: The name of your tenant.

Obtaining the Client ID and Secret

First you will have to register a client id and secret, you can do this at https://tenant.sharepoint.com/_layouts/AppRegNew.aspx, replacing tenant with your tenant name. Generate a new client id and secret, give it a name and fill in an app domain and redirect URI.

Store the client id and secret somewhere, you will need them later.

Granting permissions to your client id

Next, we need to grant permissions to our client id, you can do this on https://tenant-admin.sharepoint.com/_layouts/AppInv.aspx. Fill in your client id and do a lookup.

Provide the permission request xml, I'm asking for full control on the tenant, you could ask for less permissions if needed. Don't forget to click create and consent.

<AppPermissionRequests AllowAppOnlyPolicy="true" >
  <AppPermissionRequest Scope="http://sharepoint/content/tenant" Right="FullControl" />
</AppPermissionRequests>

Getting the Realm

The realm is a unique identifier assigned to your SharePoint tenant. You can find this for your tenant at https://tenant.sharepoint.com/_layouts/AppPrincipals.aspx

Creating the flow

We now have all the blanks we needed and can start creating the flow. To be able to reuse the settings, I've put them inside a Parse JSON block. Fill in your own realm and target host.

Next we will construct the client id and scope that are used in the request, I'm putting these in a separate step since they include the @ symbol which is a special character for Microsoft Flow.

The client id is created with a Initialize variable and formula

concat(body('Parse_JSON')?['clientId'], '@', body('Parse_JSON')?['realm'])

The scope is created with a Initialize variable and formula

concat(body('Parse_JSON')?['principal'],'/',body('Parse_JSON')?['targetHost'],'@', body('Parse_JSON')?['realm'])

Now we can get the access token with an HTTP action

This will return us a response from which you can extract the access token using the Parse JSON and finally you can use your access token to call the SharePoint API!

You can now start using the SharePoint API for all your GETs, for CREATE, PUT, PATCH, DELETE you will need to fetch a digest token as well.

Showing a panel from your CommandSet in SPFx solution

Thu, 25 Jan 2018 10:50:00 +0000

In this blog post I will illustrate how you can build an SPFx solution that will open up a panel at the side when clicking a button in the commandbar in SharePoint Online. I'll illustrate this using React components, but it will be similar using other frameworks. With the introduction of CommandSet in SPFx, it is possible to add your custom buttons to the command bar in SharePoint Online. If you already played with the sample generated by Yeoman or had a look at the samples on the internet, you will observe that most samples stick to using the Dialog. Now, a lot of existing actions in a modern SharePoint Online site pop up that pane at the right. What if you want this as well?

Use yeoman to generate a default commandset SPFx project. I'll use the Panel from Office UI Fabric and create my own React component around it, not that it is mandatory, but it will give me more control later on ... The code for my component:

import * as React from 'react';
import { Panel, PanelType } from 'office-ui-fabric-react/lib/Panel';

export default class CustomPanel extends React.Component<{}, {}> {
  public render(): React.ReactElement<{}> {
    return (
      <div>
        <Panel
          isOpen={true}
          type={ PanelType.smallFixedFar }
          headerText='U2U Panel'
          closeButtonAriaLabel='Close'
        >
        <p>Hello there!</p>
        </Panel>
      </div>
    );
  }
}

Now the trick is to make sure that when a button is clicked, that you create a div element inside your page in which you can then render your panel. You can do this inside the onExecute of the default generated code for your CommandSet. The code that does the trick looks as follows:

public onExecute(event: IListViewCommandSetExecuteEventParameters): void {
  switch (event.itemId) {
    ...
    case 'COMMAND_2':
    const div = document.createElement('div');
    const element: React.ReactElement<{} > = React.createElement(
      CustomPanel,
      {
        
      }
    );
    ReactDom.render(element, div);
    break;
    default:
    throw new Error('Unknown command');
  }
}

The result will look as follows:

C# value type boxing by interfaces - Enter generics

Wed, 24 Jan 2018 09:31:00 +0000

This blog post continues on a previously written blog post, which you can find here. In that blog post, I illustrated that interfaces are reference types, and if you use interfaces together with structs, you have to be aware that boxing and unboxing might take place.

In this article it is time to combine this with generics. The nice thing about generics is that the compiler will actually generate the corresponding code behind the scenes in order to be able to handle the templated type, a.k.a. T.

For the sake of reference, here are the interface and struct used in the previous post.

interface IBankAccount
{
    void Add(int amount);
}

struct BankAccount : IBankAccount
{
    int value;

    public BankAccount(int value) => this.value = value;
    void IBankAccount.Add(int amount) => value += amount;
    public void Add(int amount) => value += amount;
    public void Print() => Console.WriteLine($"Value: {value}");
}

Inside my console application, I defined the following generic method:

static void AddGeneric<T>(ref T ba, int amount) => ((IBankAccount)ba).Add(amount);

This method looks straightforward: it casts, whatever ba might be into the interface IBankAccount in order to invoke the Add method on it. I even pass the argument by reference, since we wouldn't want the Add to happen on a copy of the BankAccount, now would we? When we execute the following code, the result is just like before:

BankAccount ba = new BankAccount(100);
AddGeneric(ref ba, 50);
ba.Print(); // Prints 100 and not 150

The problem is still not solved, because the Add still takes place on a boxed version of the BankAccount. The compiler has to few information to deduct that you want to execute the Add method on the value type. So let's rewrite this method with constraints:

static void AddGenericContrained<T>(ref T ba, int amount) where T : IBankAccount => ba.Add(amount);

And when we execute:

BankAccount ba = new BankAccount(
AddGenericContrained(ref ba, 50);
ba.Print(); // Prints 150!!!

This seems to work, all thanks to the compiler (and the code of course). In this case, the compiler can clearly deduct that you want to execute the implementation of IBankAccount.Add on the struct (value type) BankAccount and therefore generates the appropriate code that skips the formality of boxing, and immediately applies the function.

Conclusion

If, and only if, you work with interfaces on value types, be aware of the consequences related to boxing. Remember that using generic constraint to constrain the interface method call will assist the compiler in generating the right code that directs the method call directly to the right function.

C# value type boxing by interfaces

Wed, 1 Nov 2017 09:05:00 +0000

I recently had to explain the difference between value types and reference types in .NET to people that are new to .NET and object oriented programming. This explanation then gradually roles into the concept of boxing and unboxing, where boxing is the process of converting a value type to the type object or to any interface type implemented by this value type. When boxing a value type, the CLR wraps the value inside a System.Object and stores it on the managed heap. Unboxing extracts the value type from the object and puts it on the stack.

So, when explaining boxing versus unboxing, what do you do? You put a value type inside an object and cast it back...

int i = 42;
object o = i; // boxing
i = (int)o; //unboxing

However, interfaces are reference types as well and value types can implement an interface. So boxing will also happen when you treat a value type as an interface it implements. That got me thinking ... If you consider the following code:

interface IBankAccount
{
    void Add(int amount);
}

struct BankAccount : IBankAccount
{
    int value;

    public BankAccount(int value) => this.value = value;
    void IBankAccount.Add(int amount) => value += amount;
    public void Add(int amount) => value += amount;
    public void Print() => Console.WriteLine($"Value: {value}");
}

Nothing really strange here, an interface IBankAccount that supports a method Add(int). A struct BankAccount that implements IBankAccount. The IBankAccount.Add(int) is implemented privately, and there is also a method Add(int) defined on it.

Now consider the following code

BankAccount ba = new BankAccount(100);
ba.Add(50);
ba.Print();

IBankAccount iba = ba;
iba.Add(50);
ba.Print();

This piece of code will probably not print out what you might expect... The output is as follows:

Value: 150
Value: 150

What is happening here? When creating the variable ba, the CLR will put this on the stack with an initial value of 100. Next, when executing the ba.Add(50), we add 50 to the value that is stored inside ba (on the stack), resulting in 150. Now we treat ba as its interface IBankAccount and put it inside a variable iba. This is where the boxing is happening, so the CLR takes a copy of how ba now looks like and stores this on the heap (value 150). We now call the IBankAccount.Add(int), this will increment the value on the boxed version on the heap. So this did not update the original value on the stack.