基类需要定义一个复制构造函数：

public class MyObject
{
    protected MyObject(MyObject other)
    {
        this.Prop1=other.Prop1;
        this.Prop2=other.Prop2;
    }

    public object Prop1 { get; set; }
    public object Prop2 { get; set; }
}

public class MyObjectSearch : MyObject
{

    public double Distance { get; set; }

    public MyObjectSearch(MyObject obj)
         : base(obj)
    {
        this.Distance=0;
    }
    public MyObjectSearch(MyObjectSearch other)
         : base(other)
    {
        this.Distance=other.Distance;
    }
}

这样，所有派生类的属性设置都由基类处理。

可以使用反射复制属性。

public class ChildClass : ParentClass
{

    public ChildClass(ParentClass ch)
    {
        foreach (var prop in ch.GetType().GetProperties())
        {
            this.GetType().GetProperty(prop.Name).SetValue(this, prop.GetValue(ch, null), null);
        }
    }
}

不幸的是，没有简单的方法可以做到这一点，正如你所说的，你要么使用反射，要么创建一个“Clone”方法，该方法使用父对象作为输入来生成一个新的子对象，如下所示：

public class MyObjectSearch : MyObject {

    // Other code

    public static MyObjectSearch CloneFromMyObject(MyObject obj)
    {
        var newObj = new MyObjectSearch();

        // Copy properties here
        obj.Prop1 = newObj.Prop1;

        return newObj;
    }
}

不管怎样，你要么写反射代码（这很慢），要么手工写出每个属性，这完全取决于你是想要可维护性（反射）还是速度（手工属性复制）。

一个通用的解决方案是将它序列化到json并返回.在json-string中没有关于序列化它的类名的信息.大多数人在javascript中这样做.
正如你所看到的，它对pocco对象很有效，但我不能保证它对每一个复杂的情况都有效，但是当属性匹配时，它对非继承类确实有效。

using Newtonsoft.Json;

namespace CastParentToChild
{
    public class Program
    {
        public static void Main(string[] args)
        {
            var p = new parent();
            p.a=111;
            var s = JsonConvert.SerializeObject(p);
            var c1 = JsonConvert.DeserializeObject<child1>(s);
            var c2 = JsonConvert.DeserializeObject<child2>(s);

            var foreigner = JsonConvert.DeserializeObject<NoFamily>(s);

            bool allWorks = p.a == c1.a && p.a == c2.a && p.a == foreigner.a;
            //Your code goes here
            Console.WriteLine("Is convertable: "+allWorks + c2.b);
        }
    }

    public class parent{
        public int a;
    }

    public class child1 : parent{
     public int b=12345;   
    }

    public class child2 : child1{
    }

    public class NoFamily{
        public int a;
        public int b = 99999;
    }

    // Is not Deserializeable because
    // Error 'NoFamily2' does not contain a definition for 'a' and no extension method 'a' accepting a first argument of type 'NoFamily2' could be found (are you missing a using directive or an assembly reference?)
    public class NoFamily2{
        public int b;
    }
}

如果浅层拷贝就足够了，您可以使用MemberwiseClone method。
示例：

MyObject shallowClone = (MyObject)original.MemberwiseClone();

如果您需要深层副本，可以像这样进行序列化/反序列化：https://stackoverflow.com/a/78612/1105687
一个例子（假设您按照答案中的建议编写了一个扩展方法，并将其命名为DeepClone）

MyObject deepClone = original.DeepClone();

基对象具有带属性参数的构造函数似乎是很自然的：

public class MyObject 
{
    public MyObject(prop1, prop2, ...)
    {
        this.Prop1 = prop1;
        this.Prop2 = prop2;
    }
}

因此，在后代对象中，您可以具有：

public MyObjectSearch(MyObject obj)
    :base(obj.Prop1, obj.Prop2)

这减少了与赋值相关的重复。您可以使用反射来自动复制所有属性，但这种方式似乎更具可读性。
还要注意的是，如果你的类有太多的属性，以至于你考虑自动化属性的复制，那么它们很可能违反Single Responsibility Principle，你应该考虑改变你的设计。

有图书馆来处理这个问题;但如果您只是想在一些地方快速实现，我肯定会选择前面建议的"复制构造函数"。
一个有趣的地方没有提到，如果一个对象是一个子类，那么它可以从父对象中访问子对象的私有变量!
因此，在父对象上添加一个CloneIntoChild方法。

• Order是父类
• OrderSnapshot是子类
• _bestPrice是Order上的非只读私有成员。但是Order可以为OrderSnapshot设置它。

示例：

public OrderSnapshot CloneIntoChild()
{
    OrderSnapshot sn = new OrderSnapshot()
    {
        _bestPrice = this._bestPrice,
        _closed = this._closed,
        _opened = this._opened,
        _state = this._state       
    };
    return sn;
}

注意：只读成员变量必须在构造函数中设置，因此您必须使用子构造函数来设置这些...
虽然我通常不喜欢"向上调整"，但我经常使用这种方法来分析快照...

我第一次遇到这个问题是在我想这么做的时候。如果你能使用C# 9和record-类，你只需要在子类中创建一个新的构造函数，接收一个基类对象，然后把它交给子类：

public record MyObject {
  ...
}

public record MyObjectSearch {
 public MyObjectSearch(MyObject parent) : base(parent) { }
 ...
}

然后，可以按如下方式创建子对象：

MyObject parent = new();
MyObjectSearch m = new MyObjectSearch(parentObj) { Distance = 1.1};

贷记https://stackoverflow.com/a/64573044/2582968

我建议

public class parent {
public parent(parent prnt) {prnt.referenceOnto(this);} 

private void referenceOnto(parent target) {target=this;} 
} 

Public Class child { 
public child(parent prnt) :parent(prnt) {//other fields} 
}