protected override void FormatReturnValueMethodName(DbgEvaluationInfo evalInfo, IDbgTextWriter output, DbgValueFormatterTypeOptions typeOptions, DbgValueFormatterOptions valueOptions, CultureInfo?cultureInfo, DmdMethodBase method, DmdPropertyInfo?property)
{
var typeFormatter = new Formatters.VisualBasic.VisualBasicTypeFormatter(output, typeOptions.ToTypeFormatterOptions(), null);
typeFormatter.Format(method.DeclaringType !, null);
var valueFormatter = new Formatters.VisualBasic.VisualBasicPrimitiveValueFormatter(output, valueOptions.ToValueFormatterOptions(), cultureInfo);
output.Write(DbgTextColor.Operator, ".");
if (property is not null)
{
output.Write(MemberUtils.GetColor(property), Formatters.VisualBasic.VisualBasicTypeFormatter.GetFormattedIdentifier(property.Name));
valueFormatter.WriteTokenComment(property.MetadataToken);
output.Write(DbgTextColor.Operator, ".");
output.Write(DbgTextColor.Keyword, "Get");
valueFormatter.WriteTokenComment(method.MetadataToken);
}
else
{
var operatorInfo = Formatters.VisualBasic.Operators.TryGetOperatorInfo(method.Name);
if (operatorInfo is not null && method is DmdMethodInfo methodInfo)
{
for (int i = 0; i < operatorInfo.Length; i++)
{
if (i > 0)
{
output.Write(DbgTextColor.Text, " ");
}
var s = operatorInfo[i];
output.Write('A' <= s[0] && s[0] <= 'Z' ? DbgTextColor.Keyword : DbgTextColor.Operator, s);
}
WriteGenericMethodArguments(output, method, typeFormatter);
}
public async Task <Member> FindBySsn(string ssn)
{
if (ssn == null)
{
throw new ArgumentNullException($"Ssn cannot be null.");
}
if (MemberUtils.ValidateSsn(ssn) == false)
{
throw new ArgumentException("Ssn is invalid.");
}
var memberMap = await _access.FindBySsn(ssn);
if (memberMap == null)
{
throw new NullReferenceException("Member map cannot be null.");
}
var member = _mapper.Unmap(memberMap);
if (member == null)
{
throw new NullReferenceException("Member cannot be null.");
}
return(member);
}
public override void VisitColumnReference(ColumnReference columnReference)
{
var identifiers = columnReference.Identifiers;
if (_lambdaParameters != null &&
_lambdaParameters.Count > 0 &&
_lambdaParameters.Peek().TryGetValue(identifiers.FirstOrDefault(), out var parameterExpression))
{
if (identifiers.Count > 1)
{
AddExpressionToStack(MemberUtils.GetSubfieldMember(identifiers, 1, parameterExpression, _visitorMetadata.OperationsProvider));
}
else
{
AddExpressionToStack(parameterExpression);
}
return;
}
identifiers = MemberUtils.RemoveAlias(_previousStage, identifiers);
var memberAccess = MemberUtils.GetMember(_previousStage, identifiers, _visitorMetadata.OperationsProvider, out var property);
AddUsedProperty(property);
AddExpressionToStack(memberAccess);
AddNameToStack(string.Join(".", identifiers));
}
public void ValidateNullSsnShouldReturnFalse()
{
string ssn = null;
var result = MemberUtils.ValidateSsn(ssn);
Assert.IsFalse(result);
}
public void ValidateValidPasswordShouldReturnTrue()
{
var password = "******";
var result = MemberUtils.ValidatePassword(password);
Assert.IsTrue(result);
}
public void ValidateEmptySsnShouldReturnFalse()
{
var ssn = string.Empty;
var result = MemberUtils.ValidateSsn(ssn);
Assert.IsFalse(result);
}
public void ValidateInvalidSsnShouldReturnFalse()
{
var ssn = GenerateInvalidSsn();
var result = MemberUtils.ValidateSsn(ssn);
Assert.IsFalse(result);
}
protected override void FormatPropertyName(ITextColorWriter output, DmdPropertyInfo property)
{
var name = Formatters.VisualBasic.VisualBasicTypeFormatter.GetFormattedIdentifier(property.Name);
var color = MemberUtils.GetColor(property);
output.Write(color, name);
}
public void ValidateEmptyPasswordShouldReturnTrue()
{
var password = string.Empty;
var result = MemberUtils.ValidatePassword(password);
Assert.IsFalse(result);
}
public void ValidateNullPasswordShouldReturnTrue()
{
string password = null;
var result = MemberUtils.ValidatePassword(password);
Assert.IsFalse(result);
}
public Task RemoveFromRole(Member member, string roleName)
{
if (member == null)
{
throw new ArgumentNullException($"Member cannot be null.");
}
MemberUtils.ValidateMember(member);
if (roleName == null)
{
throw new ArgumentNullException($"Role cannot be null.");
}
if (roleName.Length <= 0)
{
throw new ArgumentException("Role is invalid.");
}
var memberMap = _mapper.Map(member);
if (memberMap == null)
{
throw new NullReferenceException("Member map cannot be null.");
}
return(_access.RemoveMemberRole(memberMap as IMemberMap, roleName));
}
protected override void FormatPropertyName(IDbgTextWriter output, DmdPropertyInfo property)
{
var name = Formatters.CSharp.CSharpTypeFormatter.GetFormattedIdentifier(property.Name);
var color = MemberUtils.GetColor(property);
output.Write(color, name);
}
protected override void FormatReturnValueMethodName(DbgEvaluationInfo evalInfo, IDbgTextWriter output, DbgValueFormatterTypeOptions typeOptions, DbgValueFormatterOptions valueOptions, CultureInfo cultureInfo, DmdMethodBase method, DmdPropertyInfo property)
{
var typeFormatter = new Formatters.CSharp.CSharpTypeFormatter(output, typeOptions.ToTypeFormatterOptions(), null);
typeFormatter.Format(method.DeclaringType, null);
var valueFormatter = new Formatters.CSharp.CSharpPrimitiveValueFormatter(output, valueOptions.ToValueFormatterOptions(), cultureInfo);
output.Write(DbgTextColor.Operator, ".");
if ((object)property != null)
{
if (property.GetIndexParameters().Count != 0)
{
output.Write(DbgTextColor.Keyword, Keyword_this);
WriteMethodParameterList(output, method, typeFormatter, GetAllMethodParameterTypes(property.GetMethodSignature()), IndexerParenOpen, IndexerParenClose);
}
else
{
output.Write(MemberUtils.GetColor(property), Formatters.CSharp.CSharpTypeFormatter.GetFormattedIdentifier(property.Name));
}
valueFormatter.WriteTokenComment(property.MetadataToken);
output.Write(DbgTextColor.Operator, ".");
output.Write(DbgTextColor.Keyword, "get");
valueFormatter.WriteTokenComment(method.MetadataToken);
}
else
{
var methodColor = TypeFormatterUtils.GetColor(method, canBeModule: false);
if (TypeFormatterUtils.TryGetMethodName(method.Name, out var containingMethodName, out var localFunctionName))
{
output.Write(methodColor, Formatters.CSharp.CSharpTypeFormatter.GetFormattedIdentifier(containingMethodName));
output.Write(DbgTextColor.Operator, ".");
output.Write(methodColor, Formatters.CSharp.CSharpTypeFormatter.GetFormattedIdentifier(localFunctionName));
valueFormatter.WriteTokenComment(method.MetadataToken);
WriteGenericMethodArguments(output, method, typeFormatter);
}
protected override void FormatFieldName(IDbgTextWriter output, DmdFieldInfo field)
{
var name = Formatters.CSharp.CSharpTypeFormatter.GetFormattedIdentifier(field.Name);
var color = MemberUtils.GetColor(field);
output.Write(color, name);
}
public void Instance_ValueType_Field()
{
var instance = new ReferenceType();
MemberUtils.GenerateSetMethod(ReferenceType.PropertyInfo_Instance_ValueType_Field)(instance, Magic_ValueType);
Assert.Equal(Magic_ValueType, instance.Instance_ValueType_Field);
}
protected override void FormatFieldName(ITextColorWriter output, DmdFieldInfo field)
{
var name = Formatters.VisualBasic.VisualBasicTypeFormatter.GetFormattedIdentifier(field.Name);
var color = MemberUtils.GetColor(field);
output.Write(color, name);
}
public BenchmarkGet()
{
_property = typeof(BenchmarkGet).GetProperty(nameof(SomeProperty), BindingFlags.Public | BindingFlags.Instance);
_field = typeof(BenchmarkGet).GetField(nameof(SomeField), BindingFlags.Public | BindingFlags.Instance);
_getProperty = MemberUtils.GenerateGetMethod(_property);
_getField = MemberUtils.GenerateGetMethod(_field);
}
public void Static_ValueType_Property()
{
ValueType.Static_ValueType_Property = Magic_ValueType;
var getter = MemberUtils.GenerateGetMethod(ValueType.PropertyInfo_Static_ValueType_Property);
Assert.Equal(Magic_ValueType, getter(null));
}
public void Static_ReferenceType_Field()
{
ValueType.Static_ReferenceType_Field = Magic_ReferenceType;
var getter = MemberUtils.GenerateGetMethod(ValueType.FieldInfo_Static_ReferenceType_Field);
Assert.Equal(Magic_ReferenceType, getter(null));
}
public void SwissILGetField()
{
var swiss = MemberUtils.GenerateGetMethod(_field);
for (var i = 0; i < Reps; i++)
{
swiss(this);
}
}
public void SwissILGetProperty()
{
var swiss = MemberUtils.GenerateGetMethod(_property);
for (var i = 0; i < Reps; i++)
{
swiss(this);
}
}
public void Instance_ValueType_Property()
{
var instance = new ValueType();
instance.Instance_ValueType_Property = Magic_ValueType;
var getter = MemberUtils.GenerateGetMethod(ValueType.PropertyInfo_Instance_ValueType_Property);
Assert.Equal(Magic_ValueType, getter(instance));
}
public void Instance_ReferenceType_Field()
{
var instance = new ReferenceType();
instance.Instance_ReferenceType_Field = Magic_ReferenceType;
var getter = MemberUtils.GenerateGetMethod(ReferenceType.FieldInfo_Instance_ReferenceType_Field);
Assert.Equal(Magic_ReferenceType, getter(instance));
}
// TODO handle cases when it fails to insert data into db
public async Task <RentAttemptModel> RentBooks(string ssn, IEnumerable <string> isbns)
{
if (!MemberUtils.ValidateSsn(ssn))
{
throw new ArgumentException("Invalid isbn");
}
if (isbns == null || !isbns.Any())
{
throw new ArgumentException("Isbn list cannot be empty when renting books");
}
var member = await _memberRepository.FindBySsn(ssn);
var role = await _memberRepository.GetRoleName(member);
if (!Roles.CanRent(role))
{
return(RentAttemptModel.WhenUserIsInWrongRole());
}
var order = new Order()
{
MemberId = ssn,
Created = DateTime.UtcNow
};
var orderId = await _orderRepository.InsertAsyncWithIdReturn(order);
foreach (var isbn in isbns)
{
var book = await _bookRepository.GetByIsbnAsync(isbn);
if (!book.Loanable)
{
return(RentAttemptModel.WhenOneOfTheBooksIsNotLoanable());
}
var availableCopies = (await _bookCopyRepository.GetByIsbnAsync(isbn))
.Where(x => x.Available).ToList();
if (availableCopies.Count == 0)
{
return(RentAttemptModel.WhenOneOfTheBooksDoesntHaveCopiesAvailable());
}
var chosenCopy = availableCopies[0];
chosenCopy.Available = false;
var orderLine = BookRentUtils.CreateOrderLineModel(orderId, chosenCopy.Id);
await _orderLineRepository.InsertAsync(orderLine);
await _bookCopyRepository.UpdateAsync(chosenCopy);
}
return(RentAttemptModel.WhenSuccesful());
}
public override void VisitColumnReference(ColumnReference columnReference)
{
var identifiers = columnReference.Identifiers;
identifiers = MemberUtils.RemoveAlias(_previousStage, identifiers);
var memberAccess = MemberUtils.GetMember(_previousStage, identifiers, _visitorMetadata.OperationsProvider, out var property);
_usedProperties.Add(property);
_groupByExpressions.Add(new GroupByExpression(memberAccess, string.Join(".", identifiers), property));
}
public string GetShortSignature(bool asExtention)
{
var ret = base.ShortSignature;
if (IsOperator)
{
ret = ret.Remove("op_");
}
ret += MemberUtils.GetGenericListSignature(_mi);
ret += MemberUtils.GetParametersShortSignature(_mi.GetParameters(), (asExtention?1:0));
return(ret);
}
private VisitResult VisitColumnReferenceExpression_Internal(ColumnReference columnReference)
{
var identifiers = columnReference.Identifiers;
identifiers = MemberUtils.RemoveAlias(_previousStage, identifiers);
var memberAccess = MemberUtils.GetMember(_previousStage, identifiers, _visitorMetadata.OperationsProvider, out var property);
AddUsedProperty(property);
return(new VisitResult()
{
Expression = memberAccess
});
}
public void Test()
{
var tuple = ("Test", default(object));
var field = tuple.GetType()
.GetField(nameof(tuple.Item1), BindingFlags.Public | BindingFlags.Instance);
var getter = MemberUtils.GenerateGetMethod(field);
var testValue = getter(tuple);
Assert.Equal(tuple.Item1, testValue);
}
///<summary>Fires INotifyPropertyChanged.OnPropertyChanged for this given property Expression.
///Call this from a setter property to notify bindables that this property has changed.</summary>
public void RaisePropertyChanged <T>(Expression <Func <T> > property)
{
MemberInfo member = MemberUtils.GetMemberInfo(property);
#pragma warning disable 0618
OnPropertyChanged(member.Name);
#pragma warning restore 0618
BindablePropertyAttribute attr = member.GetCustomAttribute <BindablePropertyAttribute>();
if (attr != null && !attr.ListDependentPropertyNames.IsNullOrEmpty())
{
//Raise property changed on any dependent properties.
attr.ListDependentPropertyNames.ForEach(x => RaisePropertyChanged(x));
}
}
protected Module(BaseContainer container)
{
if (container == null)
{
throw new ArgumentNullException(nameof(container));
}
var actualMember = container.Member.GetMember;
_setVal = MemberUtils.GetSetMethod(actualMember);
_getVal = MemberUtils.GetGetMethod(actualMember);
ModuleContainer = container;
}
