给定2个类型为T的对象A和B，我想将A中的属性值分配给B中的相同属性，而不对每个属性进行显式赋值。
我想保存这样的代码：
b.Nombre = a.Nombre;
b.Descripcion = a.Descripcion;
b.Imagen = a.Imagen;
b.Activo = a.Activo;
做类似
的事情a.ApplyProperties(b);
有可能吗？
答案 0 :(得分：69)
因为我相信Jon的版本太复杂而且Steve的版本太简单了，我喜欢Daniel关于扩展类的想法。
另外一个通用版本很漂亮但不必要，因为所有项目都是对象。
我想自愿使用我的精益版和平均版。以上所有内容。 ：d
<强>代码：
using System;
using System.Reflection;
/// <summary>
/// A static class for reflection type functions
/// </summary>
public static class Reflection
{
/// <summary>
/// Extension for 'Object' that copies the properties to a destination object.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="destination">The destination.</param>
public static void CopyProperties(this object source, object destination)
{
// If any this null throw an exception
if (source == null || destination == null)
throw new Exception("Source or/and Destination Objects are null");
// Getting the Types of the objects
Type typeDest = destination.GetType();
Type typeSrc = source.GetType();
// Iterate the Properties of the source instance and
// populate them from their desination counterparts
PropertyInfo[] srcProps = typeSrc.GetProperties();
foreach (PropertyInfo srcProp in srcProps)
{
if (!srcProp.CanRead)
{
continue;
}
PropertyInfo targetProperty = typeDest.GetProperty(srcProp.Name);
if (targetProperty == null)
{
continue;
}
if (!targetProperty.CanWrite)
{
continue;
}
if (targetProperty.GetSetMethod(true) != null && targetProperty.GetSetMethod(true).IsPrivate)
{
continue;
}
if ((targetProperty.GetSetMethod().Attributes & MethodAttributes.Static) != 0)
{
continue;
}
if (!targetProperty.PropertyType.IsAssignableFrom(srcProp.PropertyType))
{
continue;
}
// Passed all tests, lets set the value
targetProperty.SetValue(destination, srcProp.GetValue(source, null), null);
}
}
}
用法：
/// <summary>
/// ExampleCopyObject
/// </summary>
/// <returns></returns>
public object ExampleCopyObject()
{
object destObject = new object();
this.CopyProperties(destObject); // inside a class you want to copy from
Reflection.CopyProperties(this, destObject); // Same as above but directly calling the function
TestClass srcClass = new TestClass();
TestStruct destStruct = new TestStruct();
srcClass.CopyProperties(destStruct); // using the extension directly on a object
Reflection.CopyProperties(srcClass, destObject); // Same as above but directly calling the function
//so on and so forth.... your imagination is the limits :D
return srcClass;
}
public class TestClass
{
public string Blah { get; set; }
}
public struct TestStruct
{
public string Blah { get; set; }
}
因为我感到无聊而且评论提出了linq版本
using System;
using System.Linq;
using System.Reflection;
/// <summary>
/// A static class for reflection type functions
/// </summary>
public static class Reflection
{
/// <summary>
/// Extension for 'Object' that copies the properties to a destination object.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="destination">The destination.</param>
public static void CopyProperties(this object source, object destination)
{
// If any this null throw an exception
if (source == null || destination == null)
throw new Exception("Source or/and Destination Objects are null");
// Getting the Types of the objects
Type typeDest = destination.GetType();
Type typeSrc = source.GetType();
// Collect all the valid properties to map
var results = from srcProp in typeSrc.GetProperties()
let targetProperty = typeDest.GetProperty(srcProp.Name)
where srcProp.CanRead
&& targetProperty != null
&& (targetProperty.GetSetMethod(true) != null && !targetProperty.GetSetMethod(true).IsPrivate)
&& (targetProperty.GetSetMethod().Attributes & MethodAttributes.Static) == 0
&& targetProperty.PropertyType.IsAssignableFrom(srcProp.PropertyType)
select new { sourceProperty = srcProp, targetProperty = targetProperty };
//map the properties
foreach (var props in results)
{
props.targetProperty.SetValue(destination, props.sourceProperty.GetValue(source, null), null);
}
}
}
答案 1 :(得分：64)
我在MiscUtil中有一个名为PropertyCopy的类型，它做了类似的事情 - 虽然它创建了一个新的目标类型实例并将属性复制到该类型中。
它不要求类型相同 - 它只是将所有可读属性从“源”类型复制到“目标”类型。当然，如果类型相同，那就更有可能工作了:)这是一个很浅的副本，顺便说一句。
在本答案底部的代码块中，我扩展了该类的功能。要从一个实例复制到另一个实例，它在执行时使用简单的PropertyInfo值 - 这比使用表达式树慢，但另一种方法是编写一个动态方法，我不太热。如果表现对你来说绝对至关重要，请告诉我，我会看到我能做些什么。要使用该方法，请编写如下内容：
MyType instance1 = new MyType();
// Do stuff
MyType instance2 = new MyType();
// Do stuff
PropertyCopy.Copy(instance1, instance2);
（其中Copy是使用类型推断调用的泛型方法。）
我还没准备好完成一个完整的MiscUtil版本，但这里是更新的代码，包括评论。我不会为SO编辑器重新编写它们 - 只需复制整个块。
（如果我从头开始，我也可能会在命名方面重新设计API，但我不想打破现有用户......）
#if DOTNET35
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Reflection;
namespace MiscUtil.Reflection
{
/// <summary>
/// Non-generic class allowing properties to be copied from one instance
/// to another existing instance of a potentially different type.
/// </summary>
public static class PropertyCopy
{
/// <summary>
/// Copies all public, readable properties from the source object to the
/// target. The target type does not have to have a parameterless constructor,
/// as no new instance needs to be created.
/// </summary>
/// <remarks>Only the properties of the source and target types themselves
/// are taken into account, regardless of the actual types of the arguments.</remarks>
/// <typeparam name="TSource">Type of the source</typeparam>
/// <typeparam name="TTarget">Type of the target</typeparam>
/// <param name="source">Source to copy properties from</param>
/// <param name="target">Target to copy properties to</param>
public static void Copy<TSource, TTarget>(TSource source, TTarget target)
where TSource : class
where TTarget : class
{
PropertyCopier<TSource, TTarget>.Copy(source, target);
}
}
/// <summary>
/// Generic class which copies to its target type from a source
/// type specified in the Copy method. The types are specified
/// separately to take advantage of type inference on generic
/// method arguments.
/// </summary>
public static class PropertyCopy<TTarget> where TTarget : class, new()
{
/// <summary>
/// Copies all readable properties from the source to a new instance
/// of TTarget.
/// </summary>
public static TTarget CopyFrom<TSource>(TSource source) where TSource : class
{
return PropertyCopier<TSource, TTarget>.Copy(source);
}
}
/// <summary>
/// Static class to efficiently store the compiled delegate which can
/// do the copying. We need a bit of work to ensure that exceptions are
/// appropriately propagated, as the exception is generated at type initialization
/// time, but we wish it to be thrown as an ArgumentException.
/// Note that this type we do not have a constructor constraint on TTarget, because
/// we only use the constructor when we use the form which creates a new instance.
/// </summary>
internal static class PropertyCopier<TSource, TTarget>
{
/// <summary>
/// Delegate to create a new instance of the target type given an instance of the
/// source type. This is a single delegate from an expression tree.
/// </summary>
private static readonly Func<TSource, TTarget> creator;
/// <summary>
/// List of properties to grab values from. The corresponding targetProperties
/// list contains the same properties in the target type. Unfortunately we can't
/// use expression trees to do this, because we basically need a sequence of statements.
/// We could build a DynamicMethod, but that's significantly more work :) Please mail
/// me if you really need this...
/// </summary>
private static readonly List<PropertyInfo> sourceProperties = new List<PropertyInfo>();
private static readonly List<PropertyInfo> targetProperties = new List<PropertyInfo>();
private static readonly Exception initializationException;
internal static TTarget Copy(TSource source)
{
if (initializationException != null)
{
throw initializationException;
}
if (source == null)
{
throw new ArgumentNullException("source");
}
return creator(source);
}
internal static void Copy(TSource source, TTarget target)
{
if (initializationException != null)
{
throw initializationException;
}
if (source == null)
{
throw new ArgumentNullException("source");
}
for (int i = 0; i < sourceProperties.Count; i++)
{
targetProperties[i].SetValue(target, sourceProperties[i].GetValue(source, null), null);
}
}
static PropertyCopier()
{
try
{
creator = BuildCreator();
initializationException = null;
}
catch (Exception e)
{
creator = null;
initializationException = e;
}
}
private static Func<TSource, TTarget> BuildCreator()
{
ParameterExpression sourceParameter = Expression.Parameter(typeof(TSource), "source");
var bindings = new List<MemberBinding>();
foreach (PropertyInfo sourceProperty in typeof(TSource).GetProperties(BindingFlags.Public | BindingFlags.Instance))
{
if (!sourceProperty.CanRead)
{
continue;
}
PropertyInfo targetProperty = typeof(TTarget).GetProperty(sourceProperty.Name);
if (targetProperty == null)
{
throw new ArgumentException("Property " + sourceProperty.Name + " is not present and accessible in " + typeof(TTarget).FullName);
}
if (!targetProperty.CanWrite)
{
throw new ArgumentException("Property " + sourceProperty.Name + " is not writable in " + typeof(TTarget).FullName);
}
if ((targetProperty.GetSetMethod().Attributes & MethodAttributes.Static) != 0)
{
throw new ArgumentException("Property " + sourceProperty.Name + " is static in " + typeof(TTarget).FullName);
}
if (!targetProperty.PropertyType.IsAssignableFrom(sourceProperty.PropertyType))
{
throw new ArgumentException("Property " + sourceProperty.Name + " has an incompatible type in " + typeof(TTarget).FullName);
}
bindings.Add(Expression.Bind(targetProperty, Expression.Property(sourceParameter, sourceProperty)));
sourceProperties.Add(sourceProperty);
targetProperties.Add(targetProperty);
}
Expression initializer = Expression.MemberInit(Expression.New(typeof(TTarget)), bindings);
return Expression.Lambda<Func<TSource, TTarget>>(initializer, sourceParameter).Compile();
}
}
}
#endif
答案 2 :(得分：20)
基于史蒂夫的方法，我选择了扩展方法。 这使用我的基类作为类型，但即使使用object作为param类型也应该可用。 适合我的用途。
using System.Reflection;
//*Namespace Here*
public static class Ext
{
public static void CopyProperties(this EntityBase source, EntityBase destination)
{
// Iterate the Properties of the destination instance and
// populate them from their source counterparts
PropertyInfo[] destinationProperties = destination.GetType().GetProperties();
foreach (PropertyInfo destinationPi in destinationProperties)
{
PropertyInfo sourcePi = source.GetType().GetProperty(destinationPi.Name);
destinationPi.SetValue(destination, sourcePi.GetValue(source, null), null);
}
}
}
用法如下：
item1.CopyProperties(item2);
现在，Item2具有与item1相同的属性数据。
答案 3 :(得分：15)
这是一个简短而又甜蜜的版本，因为你说你的两个对象属于同一类型：
foreach (PropertyInfo property in typeof(YourType).GetProperties())
{
property.SetValue(targetObject, property.GetValue(sourceObject, null), null);
}
答案 4 :(得分：6)
修改Daniel版本以避免例外。
foreach (PropertyInfo property in typeof(YourType).GetProperties())
{
if (property.CanWrite)
{
property.SetValue(marketData, property.GetValue(market, null), null);
}
}
答案 5 :(得分：2)
您可以使用序列化来深度克隆对象：
public static T DeepClone<T>(this T objectToClone) where T: BaseClass
{
BinaryFormatter bFormatter = new BinaryFormatter();
MemoryStream stream = new MemoryStream();
bFormatter.Serialize(stream, objectToClone);
stream.Seek(0, SeekOrigin.Begin);
T clonedObject = (T)bFormatter.Deserialize(stream);
return clonedObject;
}
当然，必须将类标记为Serializable。
答案 6 :(得分：1)
有ICloneable和object.MemberwiseClone（浅层副本）（这些会创建一个全新的对象，因此可能无法满足您的要求）。
您可以使用反射来自己完成（从基类继承，因此您不必重新实现）。
或者您可以编码生成它。
答案 7 :(得分：1)
你可能会尝试这样的事情......
MyType destination = new MyType();
MyType source = new MyType();
// Iterate the Properties of the destination instance and
// populate them from their source counterparts
PropertyInfo[] destinationProperties = destination.GetType().GetProperties();
foreach (PropertyInfo destinationPI in destinationProperties)
{
PropertyInfo sourcePI = source.GetType().GetProperty(destinationPI.Name);
destinationPI.SetValue(destination,
sourcePI.GetValue(source, null),
null);
}
答案 8 :(得分：1)
这种简短的扩展方法将允许您通过将Null值选中来将匹配的属性从一个对象复制到另一个对象，并且是可写的。
public static void CopyPropertiesTo(this object fromObject, object toObject)
{
PropertyInfo[] toObjectProperties = toObject.GetType().GetProperties();
foreach (PropertyInfo propTo in toObjectProperties)
{
PropertyInfo propFrom = fromObject.GetType().GetProperty(propTo.Name);
if (propFrom!=null && propFrom.CanWrite)
propTo.SetValue(toObject, propFrom.GetValue(fromObject, null), null);
}
}
答案 9 :(得分：1)
几年来，我一直在使用一个流行的库来命名 ValueInjecter
nuget：https://www.nuget.org/packages/ValueInjecter/
github：https://github.com/omuleanu/ValueInjecter
target.InjectFrom(source);
target.InjectFrom<Injection>(source);
target.InjectFrom(new Injection(parameters), source);
target.InjectFrom<Injection>(); // without source
请注意，即使基本解决方案非常简单（请参见其他答案），也有很多边缘情况（例如，深拷贝，泛型，空值）和优化（例如，缓存反映的属性），因此更好地使用维护的库为此。
答案 10 :(得分：1)
基本上在2019年，我们可能应该使用更多最新的语言功能，例如表达式树和已编译的lambda表达式，而不是Reflection
由于找不到符合我要求（最重要的是速度）的“浅克隆器”，我决定自己创建一个。它枚举了所有的gettable / settable属性，然后创建一个Block表达式，然后对其进行编译和缓存。这使其比流行的AutoMapper快13倍。用法很简单：
DestType destObject = PropMapper<SourceType, DestType>.From(srcObj);
您可以在此处查看完整的源代码：https://jitbit.github.io/PropMapper/
答案 11 :(得分：0)
如果你想要像ApplyProperties这样的东西，你可以在Object上编写一个扩展方法，它可以满足你的需要。只是意识到这样的扩展方法不会是“纯粹的”，或者是无副作用的。但是如果你需要这种能力，它就是一种完成它的方法。
答案 12 :(得分：0)
也许这篇文章有点老了，答案还是不错的，但是当您需要将许多对象映射到目标类型中时-遍历属性可能会很昂贵（想象100个道具及更多）。
我使用此AutoMapFactory方法（仅需要LinQ），它将仅在属性中迭代一次，并且每个对象的映射将非常快（100000个道具/秒）
private Func<S,T> AutoMapFactory<S,T>() where T: class, new() where S : class
{
List<Action<T, S>> mapActions = typeof(T).GetProperties().Where(tp => tp.CanWrite)
.SelectMany(tp => typeof(S).GetProperties().Where(sp => sp.CanRead)
.Where(sp => sp.Name == tp.Name && tp.PropertyType.IsAssignableFrom(sp.PropertyType))
.Select(sp => (Action<T,S>)((targetObj, sourceObj) =>
tp.SetValue(targetObj, sp.GetValue(sourceObj)))))
.ToList();
return sourceObj => {
if (sourceObj == null) return null;
T targetObj = new T();
mapActions.ForEach(action => action(targetObj, sourceObj));
return targetObj;
};
}
如何使用它：
...
var autoMapper = AutoMapFactory<SourceType, TargetType>(); //Get Only 1 instance of the mapping function
...
someCollection.Select(item => autoMapper(item)); //Almost instantaneous
...
答案 13 :(得分：0)
扩展@Azerothians答案，我需要一些其他要求：
想知道属性是否已复制（以确定是否需要更新数据库）
/// <summary>
/// Extension for 'Object' that copies the properties to a destination object.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="destination">The destination.</param>
/// <param name="PropertiesToIgnore">an optional list of property names which will NOT be copied</param>
/// <param name="IgnoreNullProperties">when true will not update properties where the source is null</param>
/// <param name="CoerceDataType">when true, will attempt to coerce the source property to the destination property (e.g. int to decimal) </param>
/// <param name="ThrowOnTypeMismatch">when true, will throw a InvalidCastException if the data cannot be coerced</param>
/// <exception cref="InvalidCastException">if there is a data type mismatch between source/destination and ThrowOnTypeMismatch is enabled and unable to coerce the data type.</exception>
/// <returns>true if any properties were changed</returns>
public static bool CopyProperties(this object source, object destination, IEnumerable<string> PropertiesToIgnore = null, bool IgnoreNullProperties = false, bool ThrowOnTypeMismatch = true, bool CoerceDataType = true)
{
if (source is null)
throw new ArgumentNullException(nameof(source));
if (destination is null)
throw new ArgumentNullException(nameof(destination));
// Getting the Types of the objects
Type typeDest = destination.GetType();
Type typeSrc = source.GetType();
// Collect all the valid properties to map
var results = (from srcProp in typeSrc.GetProperties()
let targetProperty = typeDest.GetProperty(srcProp.Name)
where srcProp.CanRead
&& targetProperty != null
&& (targetProperty.GetSetMethod(true) != null && !targetProperty.GetSetMethod(true).IsPrivate)
&& (targetProperty.GetSetMethod().Attributes & MethodAttributes.Static) == 0
&& !(
from i in PropertiesToIgnore ?? Enumerable.Empty<string>()
select i
).Contains(srcProp.Name)
&& (!IgnoreNullProperties || srcProp.GetValue(source, null) != null)
select new { sourceProperty = srcProp, targetProperty = targetProperty }).ToList();
bool PropertyChanged = false;
//map the properties
foreach (var props in results)
{
var srcValue = props.sourceProperty.GetValue(source, null);
var dstValue = props.targetProperty.GetValue(destination, null);
if (props.targetProperty.PropertyType.IsAssignableFrom(props.sourceProperty.PropertyType))
props.targetProperty.SetValue(destination, srcValue, null);
else
{
try
{
if (!CoerceDataType)
throw new InvalidCastException($"Types do not match, source: {props.sourceProperty.PropertyType.FullName}, target: {props.targetProperty.PropertyType.FullName}.");
if (srcValue != null)
{
// determine if nullable type
Type tgtType = Nullable.GetUnderlyingType(props.targetProperty.PropertyType);
// if it is, use the underlying type
// without this we cannot convert int? -> decimal? when value is not null
if (tgtType != null)
props.targetProperty.SetValue(destination, Convert.ChangeType(srcValue, tgtType, CultureInfo.InvariantCulture), null);
else // otherwise use the original type
props.targetProperty.SetValue(destination, Convert.ChangeType(srcValue, props.targetProperty.PropertyType, CultureInfo.InvariantCulture), null);
}
else // if null we can just set it as null
props.targetProperty.SetValue(destination, null, null);
}
catch (Exception ex)
{
if (ThrowOnTypeMismatch)
throw new InvalidCastException($"Unable to copy property {props.sourceProperty.Name} with value {srcValue} from object of type ({typeSrc.FullName}) to type ({typeDest.FullName}), Error: {ex.Message}");
// else ignore update
}
var newdstValue = props.targetProperty.GetValue(destination, null);
if (newdstValue == null && dstValue != null || !newdstValue.Equals(dstValue))
PropertyChanged = true;
}
}
return PropertyChanged;
}
答案 14 :(得分：0)
我已经采用了@Shimmy Weitzhandler 上面写的所有内容并稍作修改。由于我在必须定义多个具有相同属性的对象时使用此方法，因此我创建了一个接受可变数量元素的函数：
public static void CopyProperties<T>(T source, params T[] dests)
{
if(source == null)
return;
foreach (var dest in dests)
{
foreach (System.Reflection.PropertyInfo property in typeof(Button).GetProperties().Where(p => p.CanWrite))
property.SetValue(dest, property.GetValue(source, null), null);
}
}
通过它，您可以定义一个或多个元素。 例如：
Helper.CopyProperties(btn_Src, bt_Dest1);
或
Helper.CopyProperties(btn_Src, bt_Dest1, btn_Dest2, btn_Dest3);
我将它设为静态，因为我的 Helper 库中有它
答案 15 :(得分：-1)
MainDialog