Is there a shorthand for "passthrough" properties in C#?

I'm implementing a "save/load" function in my app. There are various types of Vertex object that have a lot of static fields, but apparently you can't serialize static fields. I'm making a class whose instance contains these fields, and to avoid too much code to populate these fields I'm implementing them as properties.

However, the syntax to do this seems too bulky, so I'm looking for a way to simplify this:

public Color CircleFillColor { get => CircleVertex.fillColor; set => CircleVertex.fillColor = value; }
public Color SquareFillColor { get => SquareVertex.fillColor; set => SquareVertex.fillColor = value; }
public Color TriangleFillColor { get => TriangleVertex.fillColor; set => TriangleVertex.fillColor = value; }

If we had macros in C#, I could write something like this:

#define passthru(F) { get => F; set => F = value; }
public Color CircleFillColor passthru(CircleVertex.fillColor)
public Color SquareFillColor passthru(SquareVertex.fillColor)
public Color TriangleFillColor passthru(TriangleVertex.fillColor)

Is there any shorthand for properties like this?

There isn't a direct equivalent to macros. An alternative would be to encapsulate the calls which yields minimally shorter properties at the expense of two additional methods and moves the affected fillColor property to a single method each instead of repeating it twice in every property.

public Color CircleFillColor { get => GetColor(CircleVertex); set => SetColor(CircleVertex, value); }
public Color SquareFillColor { get => GetColor(SquareVertex); set => SetColor(SquareVertex, value); }
public Color TriangleFillColor { get => GetColor(TriangleVertex); set => SetColor(TriangleVertex, value); }

private Vertex GetColor(Vertex vertex)
{
  return vertex.fillColor;
}

private void SetColor(Vertex vertex, Color color)
{
  vertex.fillColor = color;
}

I ended up using T4 text templates included in Visual Studio. As my goal was to reduce the amount of code that I needed to write by hand, so that there would be less of a chance to make a mistake while e.g. copy/pasting code.

In my project there are types of CircleVertex, SquareVertex and TriangleVertex, each of which has a separate fillColor and strokeColor. This can be thought of as a nested loop, and T4 allows to write it this way.

As an example, here's the code I ended up using. The relevant syntax parts are that things in <# ... #> is C# code, and <#= foo #> is replaced with the value of foo when this line is encountered.

<#
String[] shapes = new String[] {"Circle","Square","Triangle"};
String[] colors = new String[] {"fillColor", "strokeColor"};
foreach(var shape in shapes){
    foreach(var color in colors){
#>
[XmlElement(Type = typeof(XmlColor))]
public Color <#=shape#>_<#=color#>
{
    get => <#=shape#>Vertex.<#=color#>;
    set => <#=color#>Vertex.<#=shape#> = value; 
}
<#}#>

This expands to:

[XmlElement(Type = typeof(XmlColor))]
public Color Circle_fillColor
{
    get => CircleVertex.fillColor;
    set => CircleVertex.fillColor = value;
}
[XmlElement(Type = typeof(XmlColor))]
public Color Circle_strokeColor
{
    get => CircleVertex.strokeColor;
    set => CircleVertex.strokeColor = value;
}
[XmlElement(Type = typeof(XmlColor))]
public Color Square_fillColor
{
    get => SquareVertex.fillColor;
    set => SquareVertex.fillColor = value;
}

...snip...

[XmlElement(Type = typeof(XmlColor))]
public Color Triangle_strokeColor
{
    get => TriangleVertex.strokeColor;
    set => TriangleVertex.strokeColor = value;
}

</details>