There’s a couple of ways this can be done, using policy. As you’ve discovered, the StringCollection methods are not sufficient to achieve the desired outcome. So, we’ll treat the collection as a simple string.

In an ideal scenario, the number of elements in the collection would be known. In reality, I suspect the number of elements in myclaim can vary.

Suppose they were fixed, we could quite easily use SetClaimsIfRegexMatch and StringSplit methods to get the split claims. Here’s an example:

Fixed Number of Elements RegEx Method

We can use named capture groups with the SetClaimsIfRegexMatch transformation method. We use the extractGroups parameter to tell the method to output claims according to our capture groups.

This expression will give us what we want.

[s*(?<match_0>"[^"]*"s*,s*"[^"]*",s*"[^"]*"),(?<match_1>"[^"]*"s*,s*"[^"]*",s*"[^"]*"),(?<match_2>"[^"]*"s*,s*"[^"]*",s*"[^"]*")

• [: Literal character open square bracket.
• s*: Zero or more whitespace characters.
• (?<match_x>...): Capture group named match_x. Returns everything that matches the expression … as a group with name match_x.
• "[^"]*": Literal double quote, followed by 0 or more characters excluding a double quote, followed by double quote. In short, any double quote encapsulated string.

This expression contains some special characters in the context of XML. Normally we would escape these using ", >, and <. But I’m going to cheat and wrap the regex in single quotes.

We would define the ClaimsTransformatiom like this:

<ClaimsTransformation Id="myclaimRegexTransform" TransformationMethod="SetClaimsIfRegexMatch">
  <InputClaims>
    <!-- Specify the claim we want to work on -->
    <InputClaim ClaimTypeReferenceId="myclaim" TransformationClaimType="claimToMatch" />
  </InputClaims>
  <InputParameters>
    <!-- Use matchTo parameter to specify our regular expression -->
    <InputParameter Id="matchTo" DataType="string" Value='[s*(?<match_0>"[^"]*"s*,s*"[^"]*",s*"[^"]*"),(?<match_1>"[^"]*"s*,s*"[^"]*",s*"[^"]*"),(?<match_2>"[^"]*"s*,s*"[^"]*",s*"[^"]*")' />
    <!-- Use extractGroups parameter to instruct the method to extract groups to new output claims -->
    <InputParameter Id="extractGroups" DataType="boolean" Value="true" />
  </InputParameters>
  <OutputClaims>
    <!-- Define which claims we want out of the capture groups -->
    <OutputClaim ClaimTypeReferenceId="match_0" />
    <OutputClaim ClaimTypeReferenceId="match_1" />
    <OutputClaim ClaimTypeReferenceId="match_2" />
  </OutputClaims>
</ClaimsTransformation>

Resulting claims:

match_0 = "val1", "val2"

match_1 = "val3", "val4"

match_2 = "val5", "val6"

When this transform is applied, we end up with 3 new claims being added to the bag. But, at this stage, they’ve been stripped of the square brackets required by the JSON specification. This may or may not be an issue, since you can add these back in your application or relying party, if required.

To get the proper format, we can use StringSplit. This method is quite forgiving of quotes and spacing, or lack thereof, in our string:

<ClaimsTransformation Id="match_0_split" TransformationMethod="StringSplit">
  <InputClaims>
    <InputClaim ClaimTypeReferenceId="match_0" TransformationClaimType="inputClaim" />
  </InputClaims>
  <InputParameters>
  <InputParameter DataType="string" Id="delimiter" Value="," />
    </InputParameters>
  <OutputClaims>
    <OutputClaim ClaimTypeReferenceId="myclaim_0" TransformationClaimType="outputClaim" />
  </OutputClaims>
</ClaimsTransformation>

<ClaimsTransformation Id="match_1_split" TransformationMethod="StringSplit">
  <InputClaims>
    <InputClaim ClaimTypeReferenceId="match_1" TransformationClaimType="inputClaim" />
  </InputClaims>
  <InputParameters>
  <InputParameter DataType="string" Id="delimiter" Value="," />
    </InputParameters>
  <OutputClaims>
    <OutputClaim ClaimTypeReferenceId="match_1" TransformationClaimType="outputClaim" />
  </OutputClaims>
</ClaimsTransformation>

<ClaimsTransformation Id="match_2_split" TransformationMethod="StringSplit">
  <InputClaims>
    <InputClaim ClaimTypeReferenceId="match_2" TransformationClaimType="inputClaim" />
  </InputClaims>
  <InputParameters>
  <InputParameter DataType="string" Id="delimiter" Value="," />
    </InputParameters>
  <OutputClaims>
    <OutputClaim ClaimTypeReferenceId="myclaim_2" TransformationClaimType="outputClaim" />
  </OutputClaims>
</ClaimsTransformation>

You can adapt this XML and RegEx to suit your requirements.

Variable Number of Elements

The best way to deal with a scenario where you have a variable number of elements is to create a new claim for each string in the collection.

myclaim_0
myclaim_1
myclaim_2
...
myclaim_10 (however many you need)

We also use SetClaimsIfRegexMatch in this scenario. We just need to be mindful that, however many capture groups we declare in our regular expression, this becomes a hard limit on claims returned. Ie. If you go up to myclaim_10, but your myclaim value has 16 strings, the last 5 will be trimmed. So, try to overprovision. Overprivisioning should not result in a detrimentlal or problematic outcome, since we can make the capture groups optional.

The expression required here will be slightly different, since it still needs to match whether there’s 1 string, or 20.

The regular expression limit should be no less than 2000 characters in the policy engine, so we have lots of room to play with.

[?s*(?<myclaim_0>"[^"]*)?s*,?s*(?<myclaim_1>"[^"]*)?s*,?s*(?<myclaim_2>"[^"]*)?s*,?s*(?<myclaim_3>"[^"]*)?s*,?s*(?<myclaim_4>"[^"]*)?s*,?s*(?<myclaim_5>"[^"]*)?s*,?s*(?<myclaim_6>"[^"]*)?s*,?s*(?<myclaim_7>"[^"]*)?s*,?s*(?<myclaim_8>"[^"]*)?s*,?s*(?<myclaim_9>"[^"]*)?s*,?s*(?<myclaim_10>"[^"]*)?.*

Here, we make the capture groups and commas optional, using ?, to cater for scenarios where we have less string collection elements than capture groups.

We use the same XML as the earlier example, but we will add more output claims to match the additional named capture groups.

<ClaimsTransformation Id="myclaimRegexTransform" TransformationMethod="SetClaimsIfRegexMatch">
  <InputClaims>
    <!-- Specify the claim we want to work on -->
    <InputClaim ClaimTypeReferenceId="myclaim" TransformationClaimType="claimToMatch" />
  </InputClaims>
  <InputParameters>
    <!-- Use matchTo parameter to specify our regular expression -->
    <InputParameter Id="matchTo" DataType="string" Value='[?s*(?<myclaim_0>"[^"]*)?s*,?s*(?<myclaim_1>"[^"]*)?s*,?s*(?<myclaim_2>"[^"]*)?s*,?s*(?<myclaim_3>"[^"]*)?s*,?s*(?<myclaim_4>"[^"]*)?s*,?s*(?<myclaim_5>"[^"]*)?s*,?s*(?<myclaim_6>"[^"]*)?s*,?s*(?<myclaim_7>"[^"]*)?s*,?s*(?<myclaim_8>"[^"]*)?s*,?s*(?<myclaim_9>"[^"]*)?s*,?s*(?<myclaim_10>"[^"]*)?.*' />
    <!-- Use extractGroups parameter to instruct the method to extract groups to new output claims -->
    <InputParameter Id="extractGroups" DataType="boolean" Value="true" />
  </InputParameters>
  <OutputClaims>
    <!-- Define which claims we want out of the capture groups -->
    <OutputClaim ClaimTypeReferenceId="myclaim_0" />
    <OutputClaim ClaimTypeReferenceId="myclaim_1" />
    <OutputClaim ClaimTypeReferenceId="myclaim_2" />
    <OutputClaim ClaimTypeReferenceId="myclaim_3" />
    <OutputClaim ClaimTypeReferenceId="myclaim_4" />
    <OutputClaim ClaimTypeReferenceId="myclaim_5" />
    <OutputClaim ClaimTypeReferenceId="myclaim_6" />
    <OutputClaim ClaimTypeReferenceId="myclaim_7" />
    <OutputClaim ClaimTypeReferenceId="myclaim_8" />
    <OutputClaim ClaimTypeReferenceId="myclaim_9" />
    <OutputClaim ClaimTypeReferenceId="myclaim_10" />
  </OutputClaims>
</ClaimsTransformation>

Taking the example in your question, the result is:

myclaim_0 = "val1"

myclaim_1 = "val2"

myclaim_2 = "val3"

myclaim_3 = "val4"

myclaim_4 = "val5"

myclaim_5 = "val6"

The claims myclaim_[6..10] were not matched in the example. This will either result in the claims not being created, or being created with an empty value.

If you really need these strings in JSON format, you can use the StringFormat transformation method to format the string, using the format [ {0} ].

It would be better if you are able to concatenate the claims in the relying party application to reconstruct the string collection, adding the claims if they are not null.

The above methods illustrate how to define the transformations in the policy XML. You need to then implement the transformations and output claims in the building blocks, technical profile(s), and user/relying party journeys as required.

Note: You can make output claims optional by specifying the isRequired attribute in the ouputClaim element, setting it to false, which may be useful when the transformation doesn’t add all of the possible claims to the claims bag.