class A
{
 public string Name {get;set;}
}
void SetNull(ref string v) => if (v == "") v = null;
SetNull(ref a.Name);

vaa>class A
vaa>{
vaa> public string Name {get;set;}
vaa>}
vaa>void SetNull(ref string v) => if (v == "") v = null;
vaa>SetNull(ref a.Name);
vaa>

void SetNullProperty(string input, object target, string propertyName)
{
    if (input == string.Empty) SetPropertyValue(null, target, propertyName);
}

void SetPropertyValue(object input, object target, string propertyName)
{
    target.GetType().GetProperty(propertyName).SetValue(target, input);
}

SetNullProperty("", a, "Name");

vaa>class A
vaa>{
vaa> public string Name {get;set;}
vaa>}
vaa>void SetNull(ref string v) => if (v == "") v = null;
vaa>SetNull(ref a.Name);
vaa>

using System;

class A {
    public string Name { get; set; }
}

public class Ref<T> {
    public Func<T> get { get; private set; }
    public Action<T> set { get; private set; }
    Ref(Func<T> get, Action<T> set) { this.get = get; this.set = set; }
    public static Ref<T> propery<Y>(Y y, string name, params object[] index) {
        var p = typeof(Y).GetProperty(name);
        return new Ref<T>( () => (T)p.GetValue(y, index), v => p.SetValue(y, v, index) );
    }
}

class App {
    static void SetNull(ref string v) { if (v == "") v = null; }
    static void SetNull(Ref<string> v) { if (v.get() == "") v.set(null); }

    static void Main(string[] args) {
        string Name = "";
        var a = new A() { Name = "" };

        SetNull(ref Name);
        SetNull(Ref<string>.propery(a, "Name"));
    }
}

using System;
using System.Linq.Expressions;
using System.Reflection;

public class Program
{
    public static void Main()
    {
        var a = new A() { Name = "" };
        SetNull(() => a.Name);
        
    }
    public static void SetNull(Expression<Func<string>> getExpr)
    {
        var v = getExpr.Compile()();
        if (v == "")
        {
            if (getExpr.Body is MemberExpression me)
            {
                var target = Expression.Lambda(me.Expression).Compile().DynamicInvoke();
                if (me.Member is FieldInfo fi)
                    fi.SetValue(target, null);
                else if (me.Member is PropertyInfo pi)
                    pi.SetValue(target, null);
            }
        }
    }
}

public class A
{
    public string Name { get; set; }
}

S>        SetNull(() => a.Name);

var a = new A();
SetNull(v => a.Name = v, value);

void SetNull(Action<string?> action, string? value) =>
    action(value != "" : value : null);

var a = new A();
SetNull((o, v) => o.Name = v, a, "");

void SetNull<T>(Action<T, string?> action, T obj, string? value) =>
    action(obj, value == "" ? null : value);

vaa>class A
vaa>{
vaa> public string Name {get;set;}
vaa>}
vaa>void SetNull(ref string v) => if (v == "") v = null;
vaa>SetNull(ref a.Name);
vaa>

class A
{
    public string Name {get;set;}
}
void NullIfEmpty(string v) => v { Length : 0 } ? null : v;
a.Name = NullIfEmpty(a.Name);

public class Ref
{
    public static Ref<T> Property<T, Y>(Y obj, T property, [CallerArgumentExpression("property")] string? propPath = null)
    {
        var propDotPos = propPath.LastIndexOf('.') + 1;
        var propName = propPath.Substring(propDotPos);
        var p = typeof(Y).GetProperty(propName);
        return new Ref<T>(() => (T)p.GetValue(obj), v => p.SetValue(obj, v));
    }
}
public class Ref<T>
{
    public Func<T> get { get; private set; }
    public Action<T> set { get; private set; }
    public Ref(Func<T> get, Action<T> set) { this.get = get; this.set = set; }
}

        var a = new A() { Name = "" };
        SetNull(Ref.Property(a, a.Name));

using static Weird;
public class Program
{
    public static void Main()
    {
        var a = new A() { Name = "" };
        a.Name &= NullIfEmpty; // <--- !
    }
}

public class A
{
    public string Name { get; set; }
}
public abstract class Weird
{
    public abstract string? Apply(string? value);
    public static string? operator &(string str, Weird a) => a.Apply(str);
    public static readonly Weird NullIfEmpty = new Replace("", null);
    private class Replace : Weird
    {
        private string? _replace;
        private string? _by;
        public Replace(string? replace, string? by) => (_replace, _by) = (replace, by);
        public override string? Apply(string? value) => value == _replace ? _by : value;
    }
}

a.FirstName = NullIfEmpty(a.LastName);

a.Name ??= string.Empty;

a.Name &= NullIfEmpty & ToProperCase;

using PropertyChanged.SourceGenerator;

public partial class MyViewModel
{
    [Notify] private string _lastName;
    public string FullName => $"Dr. {LastName}";
}

Поля передаются по ссылке. Делаешь универсальный метод в классе и дело в шляпе.

#include <boost/range/algorithm.hpp>
#include <boost/range/adaptors.hpp>
#include <boost/phoenix.hpp>

#include <iostream>

using namespace boost::phoenix::arg_names;
using namespace boost::adaptors;
using namespace boost;
using namespace std;

int main() 
{
    vector<int> const     input  { 1, 2, 3, 4, 5, 3 };
    ostream_iterator<int> output { cout, ", " };

    range::copy(input | filtered(arg1 % 2) | transformed(arg1 * 7) | reversed | uniqued, 
                output);
            
    return 0;
}

public ref T this[int index] { get; }