public RawStateAccessor(Expression <Func <TInstance, State> > currentStateExpression,
IObserver <StateChanged <TInstance> > observer)
{
_observer = observer;
_property = GetCurrentStateProperty(currentStateExpression);
}
public StateMachineSchedule(string name, Expression <Func <TInstance, Guid?> > tokenIdExpression, ScheduleSettings <TInstance, TMessage> settings)
{
_name = name;
_settings = settings;
_tokenIdProperty = new ReadWriteProperty <TInstance, Guid?>(tokenIdExpression.GetPropertyInfo());
}
public StateMachineRequest(string requestName, Expression <Func <TInstance, Guid?> > requestIdExpression, RequestSettings settings)
{
_name = requestName;
_settings = settings;
_requestIdProperty = new ReadWriteProperty <TInstance, Guid?>(requestIdExpression.GetPropertyInfo());
}
public CompositeEventActivity(PropertyInfo propertyInfo, int flag,
CompositeEventStatus complete, Action <Composer, TInstance> completeCallback)
{
_property = new ReadWriteProperty <TInstance, CompositeEventStatus>(propertyInfo);
_flag = flag;
_complete = complete;
_completeCallback = completeCallback;
}
public StringStateAccessor(StateMachine <TInstance> machine, Expression <Func <TInstance, string> > currentStateExpression,
StateObserver <TInstance> observer)
{
_machine = machine;
_observer = observer;
_property = GetCurrentStateProperty(currentStateExpression);
}
public IntStateAccessor(Expression <Func <TInstance, int> > currentStateExpression, StateAccessorIndex <TInstance> index,
StateObserver <TInstance> observer)
{
_observer = observer;
_index = index;
_property = GetCurrentStateProperty(currentStateExpression);
}
static ReceiveEndpointSettings()
{
var propertyInfo = typeof(QueueDescription).GetProperty("InternalAutoDeleteOnIdle", BindingFlags.Instance | BindingFlags.NonPublic);
_autoDeleteOnIdle = new ReadWriteProperty <QueueDescription, TimeSpan?>(propertyInfo);
propertyInfo = typeof(QueueDescription).GetProperty("InternalEnableExpress", BindingFlags.Instance | BindingFlags.NonPublic);
_enableExpress = new ReadWriteProperty <QueueDescription, bool?>(propertyInfo);
}
public StateMachineRequest(string name, Expression <Func <TInstance, Guid?> > requestIdExpression, RequestSettings settings)
{
_name = name;
_settings = settings;
_accept = new List <string>();
AcceptResponse <TResponse>();
_requestIdProperty = new ReadWriteProperty <TInstance, Guid?>(requestIdExpression.GetPropertyInfo());
}
public void Should_be_able_to_access_a_private_setter()
{
var instance = new PrivateSetter();
PropertyInfo property = instance.GetType()
.GetProperties(BindingFlags.Instance | BindingFlags.Public)
.Where(x => x.Name == "Name")
.First();
var fastProperty = new ReadWriteProperty<PrivateSetter>(property, true);
const string expectedValue = "Chris";
fastProperty.Set(instance, expectedValue);
Assert.AreEqual(expectedValue, fastProperty.Get(instance));
}
public void Should_be_able_to_access_a_private_setter()
{
var instance = new PrivateSetter();
var property = instance
.GetType()
.GetProperties(BindingFlags.Instance | BindingFlags.Public)
.First(x => x.Name == "Name");
var fastProperty = new ReadWriteProperty <PrivateSetter>(property);
const string expectedValue = "Chris";
fastProperty.Set(instance, expectedValue);
Assert.AreEqual(expectedValue, fastProperty.Get(instance));
}
public ObjectArrayObjectMapper(ReadWriteProperty <T> property,
IObjectConverter converter)
{
_property = property;
_converter = converter;
}
public ValueValueDictionaryObjectMapper(ReadWriteProperty <T> property)
{
_property = property;
}
public EnumObjectMapper(ReadWriteProperty <T> property)
{
_property = property;
}
public ValueObjectDictionaryObjectMapper(ReadWriteProperty <T> property, IObjectConverter valueConverter)
{
_property = property;
_valueConverter = valueConverter;
}
public ValueObjectMapper(ReadWriteProperty <T> property)
{
_property = property;
_typeConverter = TypeDescriptor.GetConverter(property.Property.PropertyType);
}
public NullableValueObjectMapper(ReadWriteProperty <T> property)
{
_property = property;
}
public void WriteXml(XmlWriter writer)
{
writer.WriteElementString("ReadWriteProperty", ReadWriteProperty.ToString(CultureInfo.InvariantCulture));
writer.WriteElementString("ReadOnlyAutoProperty", SemiReadOnlyProperty.ToString(CultureInfo.InvariantCulture));
writer.WriteElementString("ReadOnlyProperty", RealReadOnlyProperty.ToString(CultureInfo.InvariantCulture));
}
public override int GetHashCode() => backingFieldOfRealReadOnlyProperty.GetHashCode() ^ ReadWriteProperty.GetHashCode() ^ SemiReadOnlyProperty.GetHashCode();
IObjectMapper <TImplementation> GetDictionaryToObjectConverter(ReadWriteProperty <TImplementation> property, Type valueType)
{
var underlyingType = Nullable.GetUnderlyingType(valueType);
if (underlyingType != null)
{
var converterType = typeof(NullableValueObjectMapper <,>).MakeGenericType(typeof(TImplementation), underlyingType);
return((IObjectMapper <TImplementation>)Activator.CreateInstance(converterType, property));
}
if (valueType.GetTypeInfo().IsEnum)
{
return(new EnumObjectMapper <TImplementation>(property));
}
if (valueType.IsArray)
{
var elementType = valueType.GetElementType();
if (ValueObject.IsValueObjectType(elementType))
{
var valueConverterType = typeof(ValueArrayObjectMapper <,>).MakeGenericType(typeof(TImplementation), elementType);
return((IObjectMapper <TImplementation>)Activator.CreateInstance(valueConverterType, property));
}
var elementConverter = _cache.GetConverter(elementType);
var converterType = typeof(ObjectArrayObjectMapper <,>).MakeGenericType(typeof(TImplementation), elementType);
return((IObjectMapper <TImplementation>)Activator.CreateInstance(converterType, property, elementConverter));
}
if (ValueObject.IsValueObjectType(valueType))
{
return(new ValueObjectMapper <TImplementation>(property));
}
if (valueType.ClosesType(typeof(IEnumerable <>)))
{
if (valueType.ClosesType(typeof(IDictionary <,>)))
{
Type[] genericArguments = valueType.GetClosingArguments(typeof(IDictionary <,>)).ToArray();
var keyType = genericArguments[0];
var elementType = genericArguments[1];
if (ValueObject.IsValueObjectType(keyType))
{
if (ValueObject.IsValueObjectType(elementType))
{
var valueConverterType = typeof(ValueValueDictionaryObjectMapper <, ,>).MakeGenericType(typeof(TImplementation), keyType, elementType);
return((IObjectMapper <TImplementation>)Activator.CreateInstance(valueConverterType, property));
}
else
{
var elementConverter = _cache.GetConverter(elementType);
var valueConverterType = typeof(ValueObjectDictionaryObjectMapper <, ,>).MakeGenericType(typeof(TImplementation), keyType, elementType);
return((IObjectMapper <TImplementation>)Activator.CreateInstance(valueConverterType, property, elementConverter));
}
}
throw new InvalidOperationException("A dictionary with a reference type key is not supported: " + property.Property.Name);
}
if (valueType.ClosesType(typeof(IList <>)) || valueType.ClosesType(typeof(IEnumerable <>)))
{
Type[] genericArguments = valueType.GetClosingArguments(typeof(IEnumerable <>)).ToArray();
var elementType = genericArguments[0];
if (ValueObject.IsValueObjectType(elementType))
{
var valueConverterType = typeof(ValueListObjectMapper <,>).MakeGenericType(typeof(TImplementation), elementType);
return((IObjectMapper <TImplementation>)Activator.CreateInstance(valueConverterType, property));
}
var elementConverter = _cache.GetConverter(elementType);
var converterType = typeof(ObjectListObjectMapper <,>).MakeGenericType(typeof(TImplementation), elementType);
return((IObjectMapper <TImplementation>)Activator.CreateInstance(converterType, property, elementConverter));
}
}
return(new ObjectObjectMapper <TImplementation>(property, _cache.GetConverter(valueType)));
}
public ObjectObjectMapper(ReadWriteProperty <T> property, IObjectConverter converter)
{
_property = property;
_converter = converter;
_typeConverter = TypeDescriptor.GetConverter(property.Property.PropertyType);
}
public StructCompositeEventStatusAccessor(PropertyInfo propertyInfo)
{
_property = new ReadWriteProperty <TInstance, CompositeEventStatus>(propertyInfo);
}
public ObjectListObjectMapper(ReadWriteProperty <T> property,
ObjectConverter converter)
{
_property = property;
_converter = converter;
}
public ValueListObjectMapper(ReadWriteProperty <T> property)
{
_property = property;
}
public InputPropertyTransform(PropertyInfo property, IPropertyProvider <TProperty, TInput> propertyProvider)
{
_propertyProvider = propertyProvider;
_property = new ReadWriteProperty(property);
}
