Parse key/value pairs from MSBuild property - msbuild

Say I have a property like:
<MyProp>Foo=Bar;Hello=World</MyProp>
This seems like a reasonably common property pattern in MSBuild. How would I go about fetching the value "World"? In an ideal world this might look something like:
$(MyProp).(Hello)
Edit: To be clear, the property is not of my own creation, it is the output from another target that is out of my control, so I cannot change the way the property is declared.

<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<MyProp>Foo=Bar;Hello=World</MyProp>
</PropertyGroup>
<Target Name="Foo">
<CreateItem Include="MyProp" AdditionalMetadata="$(MyProp)">
<Output TaskParameter="Include" ItemName="MyProp" />
</CreateItem>
<Message Text="Foo %(MyProp.Foo)" />
<Message Text="Hello %(MyProp.Hello)" />
</Target>
</Project>

You have two routes to follow as far as I am concerned
Declare a Property Group just like the following:
<PropertyGroup>
<Foo>Bar</Foo>
<Hello>World</Hello>
</PropertyGroup>
and then use the following method to access your properties
<Target Name="DoSomething">
<Message Text="Print this : $(Foo)" />
</Target>
or you might want to take ItemGroup Element approach like the following
<ItemGroup>
<MySolutionFiles Include="..\mySolution.sln" />
</ItemGroup>
<Target Name="PrintItems">
<Message Text="My Files: #(MySolutionFiles)" />
</Target>
You can have the following as well
<ItemGroup>
<MyProp
Include="Foo;Hello" />
</ItemGroup>
<Target Name="PrintMyItems">
<Message Text="MyProp: #(MyProp)" />
</Target>
If there is no choice over the input then one possible solution is parsing the input into an array and then taking it from there like the following:
<PropertyGroup>
<MyProp>Foo=Bar;Hello=World</MyProp>
<Split>$(MyProp.Split(';'))</Split>
</PropertyGroup>
and then play with the array items like the following:
<Target Name="DoPrint">
<Message text="$(Split[0])" />
</Target>
Split[0] item contains your Foo=Bar which can be split into two more strings just like above. This should keep you going for now.

You don't need a property group, it's just nice to have default values in case the user doesn't pass them.
For each property you pass, the syntax to access that property is $(PropertyName).
So if you pass:
msbuild.exe /p:P1=V1 /p:P2=V2;P3=V3
You would use the property name $(P1), $(P2), $(P3).
More on MsBuild properties here.

Related

msbuild - how to remove a string within a property

If I have
<PropertyGroup>
<Prop1>C:\asdfsa\abc;C:\sadf\def;C:\asfddsa\abc;</Prop1>
</PropertyGroup>
How do I remove all entries that contain \abc?
I want final value of $(Prop1) to be C:\sadf\def.
A property doesn't have 'entries', it's merely a string. You could fiddle with string splitting and/or regexes to erase some parts from it. On the other hand MSBuild also has Items which are more like proper lists. Going round via them is probably easier:
<Target Name="RemoveItemsFromProperty">
<PropertyGroup>
<Prop1>C:\asdfsa\abc;C:\sadf\def;C:\asfddsa\abc;</Prop1>
</PropertyGroup>
<ItemGroup>
<Items Include="$(Prop1)"/>
<FilteredItems Include="#(Items)" Condition="! $([System.String]::Copy('%(Identity)').Contains('\abc'))"/>
</ItemGroup>
<PropertyGroup>
<Prop1>#(FilteredItems)</Prop1>
</PropertyGroup>
<Message Text="$(Prop1)" />
</Target>
edit ok the regex way is easier though I'm not 100% sure my pattern covers all cases:
<Target Name="RemoveItemsFromProperty">
<PropertyGroup>
<Prop1>C:\asdfsa\abc;C:\sadf\def;C:\asfddsa\abc;</Prop1>
</PropertyGroup>
<Message Text="$([System.Text.RegularExpressions.Regex]::Replace('$(Prop1)', ';[.^;]\\abc', ''))" />
</Target>

How to check for presence of a string in a property

If I have a property
<PropertyGroup>
<MyProp>abd;efg;hij;klm</MyProp>
</PropertyGroup>
How do I parse $(MyProp) to check the presence of klm?
You can use property functions to invoke the string Contains() method to check for string occurrences. While some other options using the Items (through an Include="$(MyProp)" and checking if an item with the expected identity exists) is also possible, conditions using property functions can be used on any msbuild element, both inside and outside of targets.
Example:
<Project>
<PropertyGroup>
<MyProp>abd;efg;hij;klm</MyProp>
</PropertyGroup>
<Target Name="Build">
<Message Importance="high" Text="klm is included!" Condition="$(MyProp.Contains('klm'))" />
<PropertyGroup>
<MyProp>;$(MyProp);</MyProp>
</PropertyGroup>
<Message Importance="high" Text="exactly klm is included!" Condition="$(MyProp.Contains(';klm;'))" />
</Target>
</Project>
The second approach - pre- and appending ; and checking for ;klm; - makes sure that the string is matched as a whole in the list can deal with ;aklm.

Can I create a collection of properties nodes and refer to them as a whole?

I know I can do the following
<PropertyGroup>
<Foo>Bar</Foo>
<Foo1>Bar1</Foo1>
<Foos>$(Foo) $(foo1)</Foos>
</PropertyGroup>
<Target Name="Def">
<Message Text="$(Foos)"/>
</Target>
and get Bar Bar1
But this doesn't scale very well if you have many properties in the PropertyGroup.
Is there any way to reference a PropertyGroup or some other node and have MSBuild do the hard work for you?
I know the PropertyGroup element doesn't support it but imagine being able to do
<PropertyGroup Name="Bob">
<Foo>Bar</Foo>
<Foo1>Bar 1</Foo1>
</PropertyGroup>
<Target Name="Def">
<Message Text="$(Bob)"/>
</Target>
and get Bar Bar 1
This can be achieved using an ItemGroup and #() notation.
Example
<ItemGroup>
<Foo Include="Bar"/>
<Foo Include="Bar1"/>
</ItemGroup>
<Message Text="#(Foo)"/>
prints Bar;Bar1
notice the # symbol joins the items wt a semicolon by default. We can change this with a second paramter to #(..).
<ItemGroup>
<Foo Include="Bar"/>
<Foo Include="Bar1"/>
</ItemGroup>
<Message Text="#(Foo, ' ')"/>
prints Bar Bar1

Evaluate item multiple times

Not sure if that the right title for the question, but what I'm trying to do is this:
<ItemGroup>
<item1 Include="a;b;c;"/>
<item2 Include="x;y;z;"/>
<itemNames Include="item1;item2"/>
</ItemGroup>
<Target Name="DefaultName">
<Message Text="%(%(itemNames.Identity))"/>
</Target>
I'm expecting output to be:
a;b;c;
x;y;z;
Instead, the output is:
%(item1)
%(item2)
So my guess is that the Text property is parsed only once and the resulting string is not. Any workarounds arround this?
The following will produce the output you are looking for:
<ItemGroup>
<item1 Include="a;b;c;"/>
<item2 Include="x;y;z;"/>
<itemNames Include="item1;item2"/>
</ItemGroup>
<Target Name="DefaultName"
Outputs="%(itemNames.Identity)">
<PropertyGroup>
<ThisItem>%(itemNames.Identity)</ThisItem>
</PropertyGroup>
<ItemGroup>
<ThisItem Include="#($(ThisItem))" />
</ItemGroup>
<Message Text="#(ThisItem)" />
</Target>
...shows the following output...
DefaultName:
a;b;c
DefaultName:
x;y;z
Excerpted from MSBuild Trickery tricks #68 and 69

can msbuild resolve wildcard expressions resulting from a transform?

I expected the code below to result in identical items for List and List2 (I have a single cpp1 project in the searched path).
<ItemGroup>
<src Include="cpp1"/>
<List Include="#(src -> '..\..\..\projects\**\%(identity).vcxproj')" />
<List2 Include="..\..\..\projects\**\cpp1.vcxproj" />
</ItemGroup>
But what I get is:
List: ..\..\..\projects\**\cpp1.vcxproj
List2: ..\..\..\projects\common\cpp1\cpp1.vcxproj
So it looks like the wildcard expression is not being expanded when its the result of a transform. What am I missing here?
You can get the extra transformation, but you need to add an additional item array, and it needs to have each potential element added one at a time, with a dependent target. You also need to pass the intermediate item specification through a property,
<ItemGroup>
<src Include="cpp1"/>
<List1a Include="#(src -> '..\..\..\projects\**\%(Identity).vcxproj')" />
<List2 Include="..\..\..\projects\**\cpp1.vcxproj" />
</ItemGroup>
<Target Name="TransformWithWildcards"
Outputs="%(List1a.Identity)">
<PropertyGroup>
<_ThisList1a>#(List1a)</_ThisList1a>
</PropertyGroup>
<ItemGroup>
<List1b Include="$(_ThisList1a)" />
</ItemGroup>
</Target>
<Target Name="Transform"
DependsOnTargets="TransformWithWildcards">
<Message Text="1a. %(List1a.Identity)" />
<Message Text="1b. %(List1b.Identity)" />
<Message Text="2. %(List2.Identity)" />
</Target>
#(List1a) is the same as your original #(List), and #(List1b) contains the results you expected, after TransformWithWildcards completes.