How can I avoid repetitive code using reference types?

Let me try to demonstrate your problem and my proposal.

Assumptions

1. Your class has several similiar properties, all with value of String.
2. You have to keep the properties, because they may be required by other frameworks.
3. You have repeative code to work with the properties.

OldAddress

public class OldAddress
{
    public string City { get; set; }
    public string Region { get; set; }
}

Old Program

public class Program
{

    static OldAddress oldAddress;

    public static string GetFromDataSource(string prop)
    {
        return null;//should return your real value
    }

    public static void AssignValueOldWay()
    {
        if (oldAddress.City != null)
        {
            oldAddress.City = GetFromDataSource("City");
        }
        if (oldAddress.Region != null)
        {
            oldAddress.Region = GetFromDataSource("Region");
        }
        // more...
    }
}

NewAddress

public class NewAddress
{
    public static string[] PropNames = { "City", "Region" };
    public NewAddress()
    {
        props = new Dictionary<string, string>();
        foreach (string prop in PropNames)
        {
            props.Add(prop, "");
        }
    }

    public string City
    {
        get
        {
            return GetProperty("City");
        }
        set
        {
            SetProperty("City", value);
        }
    }
    public string Region
    {
        get
        {
            return GetProperty("Region");
        }
        set
        {
            SetProperty("Region", value);
        }
    }

    private Dictionary<string, string> props;

    public void SetProperty(string prop, string value)
    {
        props[prop] = value;
    }

    public string GetProperty(string prop)
    {
        return props[prop];
    }

}

New Program

public class Program
{

    public static string GetFromDataSource(string prop)
    {
        return null;//should return your real value
    }

    static NewAddress newAddress;

    public static void AssignValueNewWay()
    {
        foreach (string prop in NewAddress.PropNames)
        {
            if (newAddress.GetProperty(prop) != null)
            {
                newAddress.SetProperty(prop, GetFromDataSource(prop));
            }
        }
    }
}

Note my code is just to demonstrate the idea, not optimized for runtime exceptions or bad styles such as public fields, or magic strings.

After some thinking and looking on how I could manage this, I have decided to follow JAlex advise. For now I don't think this change is necessary, so I leave it be for now. What I will do is I would try make this more readable by using additional spaces and comments. As of for now my method looks something like this (after a bit of tweaking here and there) and I'm more or less happy with how readable it is

Address useOther(string Casual, string Other)
{
    Address address = 
        new Address();
    //Initialize address

    List<string> split = 
        new List<string>();
    char[] separator = 
    { 
        ',' 
    };
    //Initialize split and separators

    split.AddRange(Casual.Split(separator));
    split.AddRange(Other .Split(separator));
    RemoveBannedTokens(ref split);
    //Fill split



    for (int i = 0; i < split.Count; i++)
    {
        (address.Region, split[i]) = 
            findRegionByName(split[i]);

        if (address.Region != null)
            break;
    }
    //Trying to find region

    if (address.Region == null)
        address.Region = new Region(region);
    //If Region is not found

    ClearSplit(ref split);
    //Get rid of empty strings



    for (int i = 0; i < split.Count; i++)
    {
        (address.City, split[i]) = 
            findSityByName(split[i]);

        if (address.City != null)
            break;
    }
    //Trying to find city

    if (address.City == null)
    {
        for (int i = 0; i < split.Count; i++)
        {
            (address.City, split[i]) = 
                findSityByName(split[i], false);

            if (address.City != null)
                break;
        }
    }
    //Trying to find city with additional params

    if (address.City == null)
        return address;
    //If City is not found

    ClearSplit(ref split);
    //Get rid of empty strings



    for (int i = 0; i < split.Count; i++)
    {
        (address.Street, split[i]) = 
            findStreetByName(split[i], address.City);

        if (address.Street != null)
            break;
    }
    //Trying to find street

    string code =
        address.Region.Code.Replace("/", "") +
        address.City.Code  .Replace("/", "");
    //Initialize code

    if (address.Street == null && code.Length != 13)
        return address;
    //If Street is not found and address is not complete

    ClearSplit(ref split);
    //Finding street

    address.House = findNumbers(split);
    //Trying to find house

    return address;
}

I had some spare time, so I decided to refactor your code as a mental exercise for myself.

I still wanted to post my solution in case you are interested in seeing it. The most fundamental shift is that I oriented my thoughts from imperative programming to functional programming which resulted in a more concise code, and for people used to this paradigm, a much more readable code.

Address userOther(string Casual, string Other)
{
    var tokens = RemoveBannedTokens(Casual.Split(',', StringSplitOptions.RemoveEmptyEntries)
                                          .Concat(Other.Split(',', StringSplitOptions.RemoveEmptyEntries))
                                          .ToList());

    //Region
    var regionResult = tokens.Select(findRegionByName).FirstOrDefault(t => t.Item1 != null);
    regionResult = regionResult == default ? (region, string.Empty) : regionResult;
    tokens.Remove(regionResult.Item2);

    //City
    var cityResult = tokens.Select(findSityByName).FirstOrDefault(t => t.Item1 != null);
    cityResult = cityResult == default ? tokens.Select(t => findCityByName(t, false)).FirstOrDefault(t => t.Item1 != null) : cityResult;
    cityResult = cityResult == default ? (default(City), string.Empty) : cityResult;
    if (cityResult.Item1 == null)
    {
        return new Address(regionResult.Item1);
    }
    tokens.Remove(cityResult.Item2);

    //Street
    var streetResult = tokens.Select(t => findStreetByName(t, cityResult.Item1)).FirstOrDefault(t => t.Item1 != null);
    if (streetResult.Item1 == null &&
        (regionResult.Item1.Code.Replace("/", "") + cityResult.Item1.Code.Replace("/", "")).Length != 13)
    {
        return new Address(regionResult.Item1, cityResult.Item1);
    }
    tokens.Remove(streetResult.Item2);

    return new Address(regionResult.Item1,
                       cityResult.Item1,
                       streetResult.Item1,
                       findNumbers(tokens.Select(t => t.Replace("б/н", "")).ToArray(), cityResult.Item1.Index, streetResult.Item1.Index));
}

A few things to note:

• Since you didn't provided some methods used by this one, I was unable to test the real behavior of this approach
• I assumed that the returned second item of tuple from methods findXXXByName was the same as the value provided and didn't bother to update tokens[i] with it
• the variable region is provided nowhere in your example, but I still decided to keep it as is
• I created Address instances just when returning them, which forced me to declare multiple constructors (which you may not currently have)
• I assumed that ClearSplit() was just removing empty strings from the tokens

I hope you will find this bit of code valuable for your career path and personnal learning.