将相同的属性值分配给其他

Question

I have different classes sharing some properties of same type and name. I wish to assign same property values to each other. I explain my intention better in comments in the following pseudo-code. Is it possible in C#?

Ponder that there are a plethora of common properties but in unrelated classes, must we assign them one-by-one?

Second case is about sharing same properties but some of them may be nullable, who knows!

Side note: the classes already exist, cannot be altered, touched. Kinda sealed .

Can't it be done using nameof operator and two for loops? Compare property names if matched, assign?

using System;

namespace MainProgram
{
    class HomeFood
    {
        public DateTime Date         { get; set; }
        public string   food1        { get; set; }
        public string   food2        { get; set; }
        public int      cucumberSize { get; set; }
    }

    class AuntFood
    {
        public string   food2        { get; set; }
        public int      cucumberSize { get; set; }
        public DateTime Date         { get; set; }
        public string   food1        { get; set; }
        // extra
        public double? length { get; set; }
    }

    class GrandpaFood
    {
        public string?   food2        { get; set; }
        public int      cucumberSize { get; set; }
        public DateTime? Date         { get; set; }
        public string   food1        { get; set; }
        // extra
    }


    static class Program
    {
        public static void Main(string[] args)
        {
            var home = new HomeFood
                       {
                           Date         = new DateTime(2020, 1, 1),
                           food1        = "cucumber",
                           food2        = "tomato",
                           cucumberSize = 123
                       };

            var aunt = new AuntFood();

            /*
             First case: same types
             Expected for-each loop 
             assigning a class's property values 
             to other class's property values

             or for-loop no matter
             foreach(var property in HomeFood's properties)
                assign property's value to AuntFood's same property
             */

            var home2 = new HomeFood();
            var grandpa = new GrandpaFood
                       {
                           Date         = new DateTime(2020, 1, 1),
                           food1        = "dfgf",
                           food2        = "dfgdgfdg",
                           cucumberSize = 43534
                       };

            /*
             Second case: similar to first case
             with the exception of same type but nullable

             or for-loop no matter
             foreach(var property in GrandpaFood's properties)
                assign property's value to GrandpaFood's same property
                we don't care if it is null e.g.
                Home2's same property = property's value ?? default;
             */

        }
    }
}

Answer 1

Based on the comments in the questions, this is just to show how it can be done with reflection.

Disclaimer, this is just a very simplified example on how to use reflection to sync properties. It does not handle any special cases (modifiers, read only, type mismatch, etc)

I would strongly suggest to use automapper to achieve the qp goals.

public class Type1
{
    public string Property1 { get; set; }
    public string Property2 { get; set; }
}

public class Type2
{
    public string Property1 { get; set; }
    public string Property3 { get; set; }
}


class Program
{
    static void Main(string[] args)
    {

        var t1 = new Type1 { Property1 = "Banana" };
        var t2 = new Type2();

        var properties1 = typeof(Type1).GetProperties().ToList();
        var properties2 = typeof(Type2).GetProperties().ToList();

        foreach(var p in properties1)
        {
            var found = properties2.FirstOrDefault(i => i.Name == p.Name);
            if(found != null)
            {
                found.SetValue(t2, p.GetValue(t1));
            }
        }

        Console.WriteLine(t2.Property1);
    }
}

Answer 2

The short answer is, apply OOP. Define a base Food class and inherit from it in any specific food classes you have. You can put all the shared props in the base class.

public class Food 
{
   public string   food2  { get; set; }
   // other shared stuff
}  

class GrandpaFood : Food
{
   // other specific stuff
}

Answer 3

As others have said, use some of the Object Oriented properties, like inheriting a super class of implement an interface.

In case you go for inheritance, consider making the super class (the one you inherit from) abstract. This means that the super class itself cannot be instantiated, which greatly reduces the risk of violating the Liskov Substitutional Principle. Also it often reflects the real problem better. In your example, this would also be the case, as “food” is not an actual thing in the real world, but rather a group of things.