public MutablePropertyInfo CreateProperty(
MutableType declaringType, string name, PropertyAttributes attributes, MutableMethodInfo getMethod, MutableMethodInfo setMethod)
{
ArgumentUtility.CheckNotNull("declaringType", declaringType);
ArgumentUtility.CheckNotNullOrEmpty("name", name);
// Get method may be null.
// Set method may be null.
MemberAttributesUtility.ValidateAttributes("properties", MemberAttributesUtility.InvalidPropertyAttributes, attributes, "attributes");
if (getMethod == null && setMethod == null)
{
throw new ArgumentException("Property must have at least one accessor.", "getMethod");
}
var readWriteProperty = getMethod != null && setMethod != null;
if (readWriteProperty && getMethod.IsStatic != setMethod.IsStatic)
{
throw new ArgumentException("Accessor methods must be both either static or non-static.", "getMethod");
}
if (getMethod != null && !ReferenceEquals(getMethod.DeclaringType, declaringType))
{
throw new ArgumentException("Get method is not declared on the current type.", "getMethod");
}
if (setMethod != null && !ReferenceEquals(setMethod.DeclaringType, declaringType))
{
throw new ArgumentException("Set method is not declared on the current type.", "setMethod");
}
if (getMethod != null && getMethod.ReturnType == typeof(void))
{
throw new ArgumentException("Get accessor must be a non-void method.", "getMethod");
}
if (setMethod != null && setMethod.ReturnType != typeof(void))
{
throw new ArgumentException("Set accessor must have return type void.", "setMethod");
}
var getSignature = getMethod != null ? new PropertySignature(getMethod.ReturnType, getMethod.GetParameters().Select(p => p.ParameterType)) : null;
var setParameters = setMethod != null?setMethod.GetParameters().Select(p => p.ParameterType).ToList() : null;
var setSignature = setMethod != null ? new PropertySignature(setParameters.Last(), setParameters.Take(setParameters.Count - 1)) : null;
if (readWriteProperty && !getSignature.Equals(setSignature))
{
throw new ArgumentException("Get and set accessor methods must have a matching signature.", "setMethod");
}
var signature = getSignature ?? setSignature;
if (declaringType.AddedProperties.Any(p => p.Name == name && PropertySignature.Create(p).Equals(signature)))
{
throw new InvalidOperationException("Property with equal name and signature already exists.");
}
return(new MutablePropertyInfo(declaringType, name, attributes, getMethod, setMethod));
}
public void Create()
{
var property = typeof(Dictionary <int, string>).GetProperty("Item");
var signature = PropertySignature.Create(property);
Assert.That(signature.PropertyType, Is.SameAs(typeof(string)));
Assert.That(signature.IndexParameterTypes, Is.EqualTo(new[] { typeof(int) }));
}
private PropertyBuilder DefinePropertyImpl(string name, PropertyAttributes attributes, CallingConventions callingConvention, bool patchCallingConvention,
Type returnType, Type[] parameterTypes, PackedCustomModifiers customModifiers)
{
if (properties == null)
{
properties = new List <PropertyBuilder>();
}
PropertySignature sig = PropertySignature.Create(callingConvention, returnType, parameterTypes, customModifiers);
PropertyBuilder pb = new PropertyBuilder(this, name, attributes, sig, patchCallingConvention);
properties.Add(pb);
return(pb);
}
public void Interface()
{
var type = TypeSignature.Interface("MyInterface", ns, Accessibility.APublic);
var method = MethodSignature.Instance("MyMethod", type, Accessibility.APublic, TypeSignature.Int32, new MethodParameter(TypeSignature.String, "myParameter"));
var property = PropertySignature.Create("MyProperty", type, TypeSignature.Boolean, Accessibility.APublic, null);
var typeDef = TypeDef.Empty(type)
.AddMember(MethodDef.InterfaceDef(method))
.AddMember(PropertyDef.InterfaceDef(property));
cx.AddType(typeDef);
check.CheckOutput(cx);
}
public void StandardProperties()
{
// TODO: remove those CompilerGenerated attributes
var type = TypeSignature.Class("MyType", ns, Accessibility.APublic);
var prop = PropertySignature.Create("A", type, TypeSignature.String, Accessibility.APublic, Accessibility.AProtected);
var td = TypeDef.Empty(type).AddMember(
new PropertyDef(prop,
getter: MethodDef.Create(prop.Getter, thisP => Expression.Constant("abcd")),
setter: MethodDef.Create(prop.Setter, (thisP, xP) =>
Expression.While(FluentExpression.Box(thisP).CallMethod(MethodSignature.Object_Equals, Expression.Default(TypeSignature.Object)), Expression.Nop))
)
);
cx.AddType(td);
check.CheckOutput(cx);
}
public MutablePropertyInfo CreateProperty(
MutableType declaringType,
string name,
Type type,
IEnumerable <ParameterDeclaration> indexParameters,
MethodAttributes accessorAttributes,
Func <MethodBodyCreationContext, Expression> getBodyProvider,
Func <MethodBodyCreationContext, Expression> setBodyProvider)
{
ArgumentUtility.CheckNotNull("declaringType", declaringType);
ArgumentUtility.CheckNotNullOrEmpty("name", name);
ArgumentUtility.CheckNotNull("type", type);
ArgumentUtility.CheckNotNull("indexParameters", indexParameters);
// Get body provider may be null.
// Set body provider may be null.
MemberAttributesUtility.ValidateAttributes(
"property accessor methods", MemberAttributesUtility.InvalidMethodAttributes, accessorAttributes, "accessorAttributes");
if (getBodyProvider == null && setBodyProvider == null)
{
throw new ArgumentException("At least one accessor body provider must be specified.", "getBodyProvider");
}
var indexParams = indexParameters.ToList();
var signature = new PropertySignature(type, indexParams.Select(pd => pd.Type));
if (declaringType.AddedProperties.Any(p => p.Name == name && PropertySignature.Create(p).Equals(signature)))
{
throw new InvalidOperationException("Property with equal name and signature already exists.");
}
var attributes = accessorAttributes | MethodAttributes.SpecialName;
MutableMethodInfo getMethod = null, setMethod = null;
if (getBodyProvider != null)
{
getMethod = CreateAccessor(declaringType, "get_" + name, attributes, type, indexParams, getBodyProvider);
}
if (setBodyProvider != null)
{
var setterParams = indexParams.Concat(new[] { new ParameterDeclaration(type, "value") });
setMethod = CreateAccessor(declaringType, "set_" + name, attributes, typeof(void), setterParams, setBodyProvider);
}
return(new MutablePropertyInfo(declaringType, name, PropertyAttributes.None, getMethod, setMethod));
}
