使用JsonConvert的解决方案（而不是类型转换）

Question

是否可以使用C＃中的显式类型转换将基类对象分配给派生类引用。

我已经尝试过，它会产生运行时错误。

Answer 1

没有。对派生类的引用实际上必须引用派生类的实例（或null）。否则你会如何期待它的行为？

例如：

object o = new object();
string s = (string) o;
int i = s.Length; // What can this sensibly do?

如果您希望能够将基类型的实例转换为派生类型，我建议您编写一个方法来创建适当的派生类型实例。或者再次查看继承树并尝试重新设计，这样您就不需要首先执行此操作。

Answer 2

不，这是不可能的，因为将它分配给派生类引用就像是说“基类是派生类的完全能力的替代，它可以完成派生类可以做的所有事情”，这不是真的，因为派生类通常提供比他们的基类更多的功能（至少，这是继承背后的想法）。

您可以在派生类中编写构造函数，将基类对象作为参数，复制值。

这样的事情：

public class Base {
    public int Data;

    public void DoStuff() {
        // Do stuff with data
    }
}

public class Derived : Base {
    public int OtherData;

    public Derived(Base b) {
        this.Data = b.Data;
        OtherData = 0; // default value
    }

    public void DoOtherStuff() {
        // Do some other stuff
    }
}

在这种情况下，您将复制基础对象并获取具有派生成员默认值的全功能派生类对象。这样你也可以避免Jon Skeet指出的问题：

Base b = new Base();
Dervided d = new Derived();

b.DoStuff();    // OK
d.DoStuff();    // Also OK
b.DoOtherStuff();    // Won't work!
d.DoOtherStuff();    // OK

d = new Derived(b);  // Copy construct a Derived with values of b
d.DoOtherStuff();    // Now works!

Answer 3

我遇到了这个问题并通过添加一个带有类型参数的方法并将当前对象转换为该类型来解决它。

public TA As<TA>() where TA : Base
{
    var type = typeof (TA);
    var instance = Activator.CreateInstance(type);

     PropertyInfo[] properties = type.GetProperties();
     foreach (var property in properties)
     {
         property.SetValue(instance, property.GetValue(this, null), null);
     }

     return (TA)instance;
}

这意味着您可以在代码中使用它：

var base = new Base();
base.Data = 1;
var derived = base.As<Derived>();
Console.Write(derived.Data); // Would output 1

Answer 4

正如其他许多人所回答的那样，没有。

当我需要使用基类型作为派生类型时，我在那些不幸的场合使用以下代码。是的，它违反了Liskov替代原则（LSP），是的，大多数时候我们赞成合成而不是继承。支持Markus Knappen Johansson，其原始答案基于此。

基类中的代码：

    public T As<T>()
    {
        var type = typeof(T);
        var instance = Activator.CreateInstance(type);

        if (type.BaseType != null)
        {
            var properties = type.BaseType.GetProperties();
            foreach (var property in properties)
                if (property.CanWrite)
                    property.SetValue(instance, property.GetValue(this, null), null);
        }

        return (T) instance;
    }

允许：

    derivedObject = baseObect.As<derivedType>()

由于它使用反射，因此它“昂贵”。相应地使用。

Answer 5

不可能，因此您的运行时错误。

但是您可以将派生类的实例分配给基类类型的变量。

Answer 6

正如大家在这里所说，这是不可能的。

我更喜欢并且相当干净的方法是使用像AutoMapper这样的Object Mapper。

它将自动执行将属性从一个实例复制到另一个实例（不一定是同一类型）的任务。

Answer 7

您可以将类型为基类的变量强制转换为派生类的类型;但是，必要时，这将进行运行时检查，以查看所涉及的实际对象是否具有正确的类型。

创建后，无法更改对象的类型（尤其是，它的大小可能不同）。但是，您可以转换实例，创建第二种类型的 new 实例 - 但您需要手动编写转换代码。

Answer 8

在 c# 9.0 中，您可以尝试为此使用 records。它们具有复制所有字段的默认复制构造函数 - 无需对所有字段使用反射/构造函数。

public record BaseR
{
   public string Prop1 { get; set; }
}

public record DerivedR : BaseR
{
   public DerivedR(BaseR baseR) : base(baseR) { }
   public string Prop2 { get; set; }
}

var baseR = new BaseR { Prop1 = "base prob" };
var derivedR = new DerivedR(baseR) { Prop2 = "new prop" };

Answer 9

实际上有一种方法可以做到这一点。考虑如何使用Newtonsoft JSON从json反序列化对象。它将（或至少可以）忽略缺失的元素并填充它所知道的所有元素。

所以，我是怎么做到的。一个小代码示例将遵循我的解释。

从基类创建对象的实例并相应地填充它。
使用＆＃34; jsonconvert＆＃34; Newtonsoft json类，将该对象序列化为json字符串。
现在通过使用在步骤2中创建的json字符串反序列化来创建子类对象。这将创建具有基类的所有属性的子类的实例。

这就像一个魅力！那么......什么时候有用？有些人问这是否有意义，并建议更改OP的架构以适应这样一个事实，即您可以通过类继承（在.Net中）本地执行此操作。

就我而言，我有一个设置类，其中包含所有＆＃34; base＆＃34;服务的设置。特定服务有更多选项，而且来自不同的DB表，因此这些类继承了基类。他们都有不同的选择。因此，在检索服务的数据时，使用基础对象的实例FIRST填充值会容易得多。使用单个数据库查询执行此操作的一种方法。在那之后，我使用上面概述的方法创建子类对象。然后我进行第二次查询并填充子类对象上的所有动态值。

最终输出是一个派生类，其中设置了所有选项。对于其他新的子类重复此操作只需几行代码。它很简单，它使用经过严格测试的软件包（Newtonsoft）来实现神奇的工作。

此示例代码为vb.Net，但您可以轻松转换为c＃。

' First, create the base settings object.
    Dim basePMSettngs As gtmaPayMethodSettings = gtmaPayments.getBasePayMethodSetting(payTypeId, account_id)
    Dim basePMSettingsJson As String = JsonConvert.SerializeObject(basePMSettngs, Formatting.Indented)

    ' Create a pmSettings object of this specific type of payment and inherit from the base class object
    Dim pmSettings As gtmaPayMethodAimACHSettings = JsonConvert.DeserializeObject(Of gtmaPayMethodAimACHSettings)(basePMSettingsJson)

Answer 10

class Program
{
    static void Main(string[] args)
    {
        a a1 = new b();  
        a1.print();  
    }
}
class a
{
    public a()
    {
        Console.WriteLine("base class object initiated");
    }
    public void print()
    {
        Console.WriteLine("base");
    }
}
class b:a
{
    public b()
    {
        Console.WriteLine("child class object");
    }
    public void print1()
    {
        Console.WriteLine("derived");
    }
}

}

当我们创建子类对象时，基类对象是自动启动的，因此基类引用变量可以指向子类对象。

但反之不然，因为子类引用变量不能指向基类对象，因为没有创建子类对象。

并注意到基类引用变量只能调用基类成员。

Answer 11

扩展@ ybo的答案 - 这是不可能的，因为你拥有基类的实例实际上并不是派生类的实例。它只知道基类的成员，并且对派生类的成员一无所知。

您可以将派生类的实例强制转换为基类的实例的原因是因为派生类实际上已经是基类的实例，因为它已经具有这些成员。相反的情况不能说。

Answer 12

不，这是不可能的。

考虑ACBus是基类Bus的派生类的场景。 ACBus具有TurnOnAC和TurnOffAC等功能，可在名为ACState的字段上运行。 TurnOnAC将ACState设置为on，TurnOffAC将ACState设置为off。如果您尝试在总线上使用TurnOnAC和TurnOffAC功能，那就毫无意义了。

Answer 13

您可以使用Extention：

public static void CopyOnlyEqualProperties<T>(this T objDest, object objSource) where T : class
    {
        foreach (PropertyInfo propInfo in typeof(T).GetProperties())
            if (objSource.GetType().GetProperties().Any(z => z.Name == propInfo.Name && z.GetType() == propInfo.GetType()))
                propInfo.SetValue(objDest, objSource.GetType().GetProperties().First(z => z.Name == propInfo.Name && z.GetType() == propInfo.GetType()).GetValue(objSource));
    }

在代码中：

public class BaseClass
{
  public string test{ get; set;}
}
public Derived : BaseClass
{
//Some properies
}

public void CopyProps()
{
   BaseClass baseCl =new BaseClass();
   baseCl.test="Hello";
   Derived drv=new Derived();
   drv.CopyOnlyEqualProperties(baseCl);
   //Should return Hello to the console now in derived class.
   Console.WriteLine(drv.test);

}

Answer 14

我知道这已经很老了，但是我已经成功使用了一段时间了。

   private void PopulateDerivedFromBase<TB,TD>(TB baseclass,TD derivedclass)
    {
        //get our baseclass properties
        var bprops = baseclass.GetType().GetProperties();
        foreach (var bprop in bprops)
        {
            //get the corresponding property in the derived class
            var dprop = derivedclass.GetType().GetProperty(bprop.Name);
            //if the derived property exists and it's writable, set the value
            if (dprop != null && dprop.CanWrite)
                dprop.SetValue(derivedclass,bprop.GetValue(baseclass, null),null);
        }
    }

Answer 15

使用JsonConvert的解决方案（而不是类型转换）

今天我遇到了同样的问题，并且我发现使用int sum = 0; for (int i = 0; i < 5; i++){ int num = input.nextInt(); list.add(num); sum += num; }可以简单，快速地解决问题。

JsonConvert

Answer 16

怎么样：

public static T As<T>(this object obj)
    {
        return JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(obj));
    }

Answer 17

不是传统意义上的...转换为Json，然后转换为您的对象，然后完成！上面的Jesse首先发布了答案，但是没有使用这些扩展方法，这使过程变得非常容易。创建几个扩展方法：

    public static string ConvertToJson<T>(this T obj)
    {
        return JsonConvert.SerializeObject(obj);
    }
    public static T ConvertToObject<T>(this string json)
    {
        if (string.IsNullOrEmpty(json))
        {
            return Activator.CreateInstance<T>();
        }
        return JsonConvert.DeserializeObject<T>(json);
    }

将它们永久放置在工具箱中，那么您随时可以这样做：

var derivedClass = baseClass.ConvertToJson().ConvertToObject<derivedClass>();

啊，JSON的力量。

这种方法有两个陷阱：我们实际上是在创建一个新对象，而不是强制转换，这可能会或可能不会重要。私有字段将不会被传输，带有参数的构造函数将不会被调用，等等。有可能不会分配一些子json。流不是由JsonConvert天生处理的。但是，如果我们的类不依赖私有字段和构造函数，那么这是一种非常有效的方法，可以在不映射和调用构造函数的情况下将数据从类移动到类，这是我们首先要进行转换的主要原因。 / p>

Answer 18

您只需将基础对象序列化为JSON，然后反序列化为派生对象。

Answer 19

您可以使用一个复制构造函数，该复制构造函数立即调用该实例构造函数，或者如果您的实例构造函数所做的不只是分配，则该复制构造函数会将传入的值分配给该实例。

class Person
{
    // Copy constructor 
    public Person(Person previousPerson)
    {
        Name = previousPerson.Name;
        Age = previousPerson.Age;
    }

    // Copy constructor calls the instance constructor.
    public Person(Person previousPerson)
        : this(previousPerson.Name, previousPerson.Age)
    {
    }

    // Instance constructor.
    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }

    public int Age { get; set; }

    public string Name { get; set; }
}

在此示例中引用了Microsoft C# Documentation under Constructor，过去曾有此问题。

Answer 20

这就是我为字段解决的方法。如果需要，可以通过属性进行相同的迭代。您可能需要对null等进行一些检查，但这就是这个主意。

 public static DerivedClass ConvertFromBaseToDerived<BaseClass, DerivedClass>(BaseClass baseClass)
            where BaseClass : class, new()
            where DerivedClass : class, BaseClass, new()
        {
            DerivedClass derived = (DerivedClass)Activator.CreateInstance(typeof(DerivedClass));
            derived.GetType().GetFields().ToList().ForEach(field =>
            {
                var base_ = baseClass.GetType().GetField(field.Name).GetValue(baseClass);
                field.SetValue(derived, base_);

            });

            return derived;
        }

Answer 21

我不同意这是不可能的。您可以这样做：

public class Auto 
{ 
    public string Make {get; set;}
    public string Model {get; set;}
}

public class Sedan : Auto
{ 
    public int NumberOfDoors {get; set;}
}

public static T ConvertAuto<T>(Sedan sedan) where T : class
{
    object auto = sedan;
    return (T)loc;
}

用法：

var sedan = new Sedan();
sedan.NumberOfDoors = 4;
var auto = ConvertAuto<Auto>(sedan);

Answer 22

将所有基本属性添加到派生项的最佳方法是在构造函数中使用反射。试试此代码，而不创建方法或实例。

    public Derived(Base item) :base()
    {

        Type type = item.GetType();

        System.Reflection.PropertyInfo[] properties = type.GetProperties();
        foreach (var property in properties)
        {
            try
            {
                property.SetValue(this, property.GetValue(item, null), null);
            }
            catch (Exception) { }
        }

    }

Answer 23

另一个解决方案是添加扩展方法，如下所示：

 public static void CopyProperties(this object destinationObject, object sourceObject, bool overwriteAll = true)
        {
            try
            {
                if (sourceObject != null)
                {
                    PropertyInfo[] sourceProps = sourceObject.GetType().GetProperties();
                    List<string> sourcePropNames = sourceProps.Select(p => p.Name).ToList();
                    foreach (PropertyInfo pi in destinationObject.GetType().GetProperties())
                    {
                        if (sourcePropNames.Contains(pi.Name))
                        {
                            PropertyInfo sourceProp = sourceProps.First(srcProp => srcProp.Name == pi.Name);
                            if (sourceProp.PropertyType == pi.PropertyType)
                                if (overwriteAll || pi.GetValue(destinationObject, null) == null)
                                {
                                    pi.SetValue(destinationObject, sourceProp.GetValue(sourceObject, null), null);
                                }
                        }
                    }
                }
            }
            catch (ApplicationException ex)
            {
                throw;
            }
        }

然后在每个派生类中都有一个接受基类的构造函数：

  public class DerivedClass: BaseClass
    { 
        public DerivedClass(BaseClass baseModel)
        {
            this.CopyProperties(baseModel);
        }
    }

如果已经设置（非空），它也可以选择覆盖目标属性。

Answer 24

我结合了先前答案的某些部分（这要感谢那些作者），并将一个简单的静态类与我们正在使用的两种方法放在一起。

是的，很简单，不是，它不能涵盖所有情况，是的，它可以扩展并做得更好，不是，它不是完美的，是的，它可以提高效率，不是，这不是切片面包以来最伟大的事情，是的，那里有完整的健壮的nuget包对象映射器，对于大量使用等来说更好，等等，yada yada-但它可以满足我们的基本需求:)

当然，它将尝试将值从任何对象映射到任何对象（无论是否衍生）（只有名称相同的公共属性-忽略其余部分）。

用法：

SesameStreetCharacter puppet = new SesameStreetCharacter() { Name = "Elmo", Age = 5 };

// creates new object of type "RealPerson" and assigns any matching property 
// values from the puppet object 
// (this method requires that "RealPerson" have a parameterless constructor )
RealPerson person = ObjectMapper.MapToNewObject<RealPerson>(puppet);

// OR

// create the person object on our own 
// (so RealPerson can have any constructor type that it wants)
SesameStreetCharacter puppet = new SesameStreetCharacter() { Name = "Elmo", Age = 5 };
RealPerson person = new RealPerson("tall") {Name = "Steve"};

// maps and overwrites any matching property values from 
// the puppet object to the person object so now our person's age will get set to 5 and
// the name "Steve" will get overwritten with "Elmo" in this example
ObjectMapper.MapToExistingObject(puppet, person);

静态实用类：

public static class ObjectMapper
{
    // the target object is created on the fly and the target type 
    // must have a parameterless constructor (either compiler-generated or explicit) 
    public static Ttarget MapToNewObject<Ttarget>(object sourceobject) where Ttarget : new()
    {
        // create an instance of the target class
        Ttarget targetobject = (Ttarget)Activator.CreateInstance(typeof(Ttarget));

        // map the source properties to the target object
        MapToExistingObject(sourceobject, targetobject);

        return targetobject;
    }

    // the target object is created beforehand and passed in
    public static void MapToExistingObject(object sourceobject, object targetobject)
    {
        // get the list of properties available in source class
        var sourceproperties = sourceobject.GetType().GetProperties().ToList();

        // loop through source object properties
        sourceproperties.ForEach(sourceproperty => {

            var targetProp = targetobject.GetType().GetProperty(sourceproperty.Name);

            // check whether that property is present in target class and is writeable
            if (targetProp != null && targetProp.CanWrite)
            {
                // if present get the value and map it
                var value = sourceobject.GetType().GetProperty(sourceproperty.Name).GetValue(sourceobject, null);
                targetobject.GetType().GetProperty(sourceproperty.Name).SetValue(targetobject, value, null);
            }
        });
    }
}

Answer 25

您可以使用通用。

public class BaseClass
{
    public int A { get; set; }
    public int B { get; set; }
    private T ConvertTo<T>() where T : BaseClass, new()
    {
         return new T
         {
             A = A,
             B = B
         }
    }

    public DerivedClass1 ConvertToDerivedClass1()
    {
         return ConvertTo<DerivedClass1>();
    }

    public DerivedClass2 ConvertToDerivedClass2()
    {
         return ConvertTo<DerivedClass2>();
    }
}

public class DerivedClass1 : BaseClass
{
    public int C { get; set; }
}

public class DerivedClass2 : BaseClass
{
    public int D { get; set; }
}

使用这种方法可以获得三个好处。

您没有复制代码
你没有使用反射（这很慢）
您的所有转化都在一个地方

Answer 26

是否可以使用C＃中的显式类型转换将基类对象分配给派生类引用。

不仅可以进行显式转换，还可以进行隐式转换。

C＃语言不允许这样的转换运算符，但您仍然可以使用纯C＃编写它们并且它们可以工作。请注意，定义隐式转换运算符（Derived）的类和使用运算符（Program）的类必须在单独的程序集中定义（例如Derived类在{ {1}包含library.dll类的program.exe引用的{1}}。

Program

当您使用Visual Studio中的Project Reference引用库时，VS会在您使用隐式转换时显示波形，但它编译得很好。如果您只引用//In library.dll: public class Base { } public class Derived { [System.Runtime.CompilerServices.SpecialName] public static Derived op_Implicit(Base a) { return new Derived(a); //Write some Base -> Derived conversion code here } [System.Runtime.CompilerServices.SpecialName] public static Derived op_Explicit(Base a) { return new Derived(a); //Write some Base -> Derived conversion code here } } //In program.exe: class Program { static void Main(string[] args) { Derived z = new Base(); //Visual Studio can show squiggles here, but it compiles just fine. } }，则没有曲线。

Answer 27

可能不是相关的，但我能够在派生对象的基础上运行代码。它肯定比我想要的更黑，但它有效：

public static T Cast<T>(object obj)
{
    return (T)obj;
}

...

//Invoke parent object's json function
MethodInfo castMethod = this.GetType().GetMethod("Cast").MakeGenericMethod(baseObj.GetType());
object castedObject = castMethod.Invoke(null, new object[] { baseObj });
MethodInfo jsonMethod = baseObj.GetType ().GetMethod ("ToJSON");
return (string)jsonMethod.Invoke (castedObject,null);

Answer 28

不，请看我问过的这个问题 - Upcasting in .NET using generics

最好的方法是在类上创建默认构造函数，构造然后调用Initialise方法

是否可以使用显式类型转换将基类对象分配给派生类引用？

28 个答案:

使用JsonConvert的解决方案（而不是类型转换）