private IExpression resolveMemberSelector(Context context, MemberSelector caller) { IExpression parent = caller.getParent(); String name = caller.getName(); return(new MethodCall(new MethodSelector(parent, name), arguments)); }
public void Should_Not_Hold_Reference_To_Object() { WeakReference dataRef = null; var selector = new MemberSelector() { MemberName = "Child.StringValue" }; Action run = () => { var data = new Item() { Child = new Item() { StringValue = "Value1" } }; Assert.Same("Value1", selector.Select(data)); dataRef = new WeakReference(data); }; run(); GC.Collect(); Assert.False(dataRef.IsAlive); }
public override bool[] Share(IElementoNube elemento, bool notify = true, string message = null, SharingLevel level = SharingLevel.ViewerNoComment, params string[] emailsUsersToShare) { bool[] shared = new bool[emailsUsersToShare.Length]; List <FileMemberActionResult> results; Dropbox.Api.Sharing.AddMember[] membersFolder; Dropbox.Api.Sharing.MemberSelector[] membersFile; Dropbox.Api.Sharing.AccessLevel shareLevel = GetShareLevel(level); if (elemento.IsAFolder) { membersFolder = new Dropbox.Api.Sharing.AddMember[emailsUsersToShare.Length]; for (int i = 0; i < membersFolder.Length; i++) { membersFolder[i] = new Dropbox.Api.Sharing.AddMember(new Dropbox.Api.Sharing.MemberSelector.Email(emailsUsersToShare[i]), shareLevel); } client.Sharing.AddFolderMemberAsync(GetIdShareFolder(elemento), membersFolder, notify, message).Wait(); } else { membersFile = new MemberSelector[emailsUsersToShare.Length]; for (int i = 0; i < membersFile.Length; i++) { membersFile[i] = new MemberSelector.Email(emailsUsersToShare[i]); } results = client.Sharing.AddFileMemberAsync(elemento.PathNube, membersFile, message, notify, shareLevel).Result; for (int i = 0; i < results.Count; i++) { shared[i] = results[i].Result.IsSuccess; } } return(shared); }
/// <summary> /// Pass the <see cref="MemberInfo"/> using name on <see cref="Type"/>. /// </summary> /// <typeparam name="T">The type of <see cref="MemberInfo"/>.</typeparam> /// <param name="memberSelector">The <see cref="MemberSelector{T}"/>.</param> /// <param name="type">The <see cref="Type"/> the member is on.</param> /// <param name="memberName">The name of the member.</param> public static void ByNameForType <T>( this MemberSelector <T> memberSelector, Type type, string memberName) where T : MemberInfo { if (typeof(T) == typeof(FieldInfo)) { memberSelector.Member = new[] { type.GetField(memberName, AllFlags) as T, }; } else if (typeof(T) == typeof(PropertyInfo)) { memberSelector.Member = new[] { type.GetProperty(memberName, AllFlags) as T, }; } else if (typeof(T) == typeof(MethodInfo)) { memberSelector.Member = type.GetMethods(AllFlags) .Where(m => m.Name == memberName) .OfType <T>().ToArray(); } else { throw new InvalidOperationException(type.ToString()); } }
protected override MethodDefinition[] GetMethods() { var definitions = new List <MethodDefinition>(); var methods = InterceptableMemberHelper.GetMethods(Type).Where(m => MemberSelector.IncludeMethod(m)); // virtual foreach (var method in methods) { definitions.Add(new MethodDefinition(this, method)); } // mixins foreach (var mxinDefinition in MixinDefinitions) { foreach (var methodDefinition in mxinDefinition.MethodDefinitions) { if (MethodFinder.FindMethod(methods, methodDefinition.Method) == null) { definitions.Add(methodDefinition); } } } return(definitions.ToArray()); }
public void Should_Select_Simple_Property_Value_In_Multiple_Items() { var selector = new MemberSelector() { MemberName = "StringValue" }; var data = new Item[] { new Item() { StringValue = "Value1" }, new Item() { StringValue = "Value2" }, new Item() { StringValue = "Value3" } }; Assert.Same("Value1", selector.Select(data[0])); Assert.Same("Value2", selector.Select(data[1])); Assert.Same("Value3", selector.Select(data[2])); }
public void SetUp() { _bindingFlagsEvaluatorMock = new Mock <IBindingFlagsEvaluator> (MockBehavior.Strict); _selector = new MemberSelector(_bindingFlagsEvaluatorMock.Object); _someDeclaringType = ReflectionObjectMother.GetSomeType(); }
public void SetUp() { _bindingFlagsEvaluatorMock = MockRepository.GenerateStrictMock <IBindingFlagsEvaluator>(); _selector = new MemberSelector(_bindingFlagsEvaluatorMock); _someDeclaringType = ReflectionObjectMother.GetSomeType(); }
public void Should_Select_Null_Value_On_Null_Object() { var selector = new MemberSelector() { MemberName = "StringValue" }; Assert.Equal(null, selector.Select(null)); }
public static MethodBaseBodyContextBase GetBodyContextBase( MutableType declaringType = null, IEnumerable <ParameterExpression> parameterExpressions = null, bool isStatic = false) { declaringType = declaringType ?? GetMutableType(); parameterExpressions = parameterExpressions ?? new ParameterExpression[0]; var memberSelector = new MemberSelector(new BindingFlagsEvaluator()); return(MockRepository.GenerateStub <MethodBaseBodyContextBase> (declaringType, parameterExpressions, isStatic, memberSelector)); }
public void Should_Select_Target_On_Empty_MemberName() { var selector = new MemberSelector(); var data = new Item() { StringValue = "Value1" }; Assert.Same(data, selector.Select(data)); }
/// <summary> /// 获取成员 /// </summary> /// <param name="accessToken"></param> /// <param name="partyid"></param> /// <returns></returns> static List <MemberSelector> GetMembers(string accessToken, int deptid = -1) { List <MemberSelector> members = new List <MemberSelector>(); Member member = new Member(); var users = member.List(accessToken, deptid, Member.Fetch_Child.GetCurrent, Member.MemberStatus.All); var items = MemberSelector.ConvertTo(users).ToList(); if (items != null && items.Count > 0) { members.AddRange(items); } return(members); }
public void Should_Select_Null_Value_On_Wrong_MemberName() { var selector = new MemberSelector() { MemberName = "WrongProperty" }; var data = new Item() { StringValue = "Value1" }; Assert.Same(null, selector.Select(data)); }
public void Should_Select_Simple_Property_Value() { var selector = new MemberSelector() { MemberName = "StringValue" }; var data = new Item() { StringValue = "Value1" }; Assert.Same("Value1", selector.Select(data)); }
public void parsesMemberExpression() { String statement = "p.name"; OTestParser parser = new OTestParser(statement); IExpression e = parser.parse_instance_expression(); Assert.IsTrue(e is MemberSelector); MemberSelector me = (MemberSelector)e; Assert.AreEqual("name", me.getName()); Assert.IsTrue(me.getParent() is InstanceExpression); InstanceExpression uie = (InstanceExpression)me.getParent(); Assert.AreEqual("p", uie.getName()); }
public IExpression resolve(Context context, IParameter parameter, bool checkInstance) { // since we support implicit members, it's time to resolve them IExpression expression = getExpression(); IType requiredType = parameter.GetIType(context); IType actualType = checkActualType(context, requiredType, expression, checkInstance); bool assignable = requiredType.isAssignableFrom(context, actualType); // try passing category member if (!assignable && (actualType is CategoryType)) { expression = new MemberSelector(expression, parameter.GetName()); } return(expression); }
public void Should_Support_Change_Of_Target_Value() { var selector = new MemberSelector() { MemberName = "StringValue" }; var data = new Item() { StringValue = "Value1" }; Assert.Same("Value1", selector.Select(data)); data.StringValue = "Value2"; Assert.Same("Value2", selector.Select(data)); }
public void Should_Support_Change_Of_MemberName() { var selector = new MemberSelector() { MemberName = "StringValue" }; var data = new Item() { StringValue = "Value1", IntValue = 1 }; Assert.Same("Value1", selector.Select(data)); selector.MemberName = "IntValue"; Assert.Equal(1, selector.Select(data)); }
/// <summary> /// 获取成员 /// </summary> /// <param name="accessToken"></param> /// <param name="userinfos"></param> /// <returns></returns> static List <MemberSelector> GetMembers(string accessToken, List <User> userinfos) { if (userinfos == null || userinfos.Count == 0) { return(null); } List <MemberSelector> members = new List <MemberSelector>(); Member member = new Member(); foreach (User user in userinfos) { var _member = member.Get(accessToken, user.userid); if (_member != null && _member.errcode == 0) { members.Add(MemberSelector.ConvertTo(_member, true)); } } return(members); }
/// <summary> /// 获取成员 /// </summary> /// <param name="accessToken"></param> /// <param name="partyid"></param> /// <returns></returns> static List <MemberSelector> GetMembersAll(string accessToken, List <int> partyid) { if (partyid == null || partyid.Count == 0) { return(null); } List <MemberSelector> members = new List <MemberSelector>(); Member member = new Member(); foreach (int _partyid in partyid) { var users = member.List(accessToken, _partyid, Member.Fetch_Child.GetAll, Member.MemberStatus.All); var items = MemberSelector.ConvertTo(users).ToList(); if (items != null && items.Count > 0) { members.AddRange(items); } } return(members); }
public bool Validate(T obj) { TMember member = MemberSelector.Invoke(obj); var validate = _memberValidation.Invoke(obj, member, ValidatorExpression); if (!validate) { var formattingInfo = _validationExpressionErrorMessageFactory.Invoke(obj); ErrorMessageFormat = formattingInfo.Item1; FormatObjectArgs = formattingInfo.Item2; FormatObjectArgs.Add(member); ErrorMessage = string.Format(ErrorMessageFormat, FormatObjectArgs.ToArray()); } else { ErrorMessage = string.Empty; } return(validate); }
public void Should_Select_MoreComplex_Property_Value() { var selector = new MemberSelector() { MemberName = "Child.Child.Child.StringValue" }; var data = new Item() { Child = new Item() { Child = new Item() { Child = new Item() { StringValue = "Value1" } } } }; Assert.Same("Value1", selector.Select(data)); }
/// <summary> /// Resolves the expression based on type. /// </summary> /// <typeparam name="T">The <see cref="MemberInfo"/> to extract.</typeparam> /// <typeparam name="TTarget">The <see cref="Type"/> to extract from.</typeparam> /// <param name="memberSelector">The <see cref="MemberSelector{T}"/>.</param> /// <param name="expr">The <see cref="Expression"/>.</param> private static void Resolve <T, TTarget>( MemberSelector <T> memberSelector, Expression expr) where T : MemberInfo { if (typeof(T) == typeof(MethodInfo)) { var methodCall = expr.AsEnumerable() .OfType <MethodCallExpression>().FirstOrDefault(); memberSelector.Member = new[] { methodCall.Method as T }; } else if (typeof(T) == typeof(ConstructorInfo)) { var ctor = expr.AsEnumerable() .OfType <NewExpression>().FirstOrDefault(); memberSelector.Member = new[] { ctor.Constructor as T }; } else { var memberAccess = expr.AsEnumerable() .OfType <MemberExpression>().FirstOrDefault(); memberSelector.Member = new[] { memberAccess.Member as T }; } }
/// <summary> /// Generate an automatic hash code for an object based on members of that object. /// </summary> /// <param name="obj">The object to search.</param> /// <param name="selector">Choose what object members to use in hash code generation</param> /// <returns>A hash code</returns> public static int GetAutoHashCode(this object obj, MemberSelector selector = MemberSelector.PublicProperties) { var type = obj.GetType(); List <object> hashCodes = new List <object>(); if (selector.HasFlag(MemberSelector.PublicProperties)) { hashCodes.AddRange(type.GetProperties(BindingFlags.Public | BindingFlags.Instance).Select(p => p.GetValue(obj))); } if (selector.HasFlag(MemberSelector.PrivateProperties)) { hashCodes.AddRange(type.GetProperties(BindingFlags.NonPublic | BindingFlags.Instance).Select(p => p.GetValue(obj))); } if (selector.HasFlag(MemberSelector.PublicFields)) { hashCodes.AddRange(type.GetFields(BindingFlags.Public | BindingFlags.Instance).Select(p => p.GetValue(obj))); } if (selector.HasFlag(MemberSelector.PrivateFields)) { hashCodes.AddRange(type.GetFields(BindingFlags.Public | BindingFlags.Instance).Select(p => p.GetValue(obj))); } return(GetAutoHashCode(null, hashCodes.ToArray())); }
/// <summary> /// <para>Begins an asynchronous send to the update folder member route.</para> /// </summary> /// <param name="sharedFolderId">The ID for the shared folder.</param> /// <param name="member">The member of the shared folder to update. Only the <see /// cref="MemberSelector.DropboxId" /> may be set at this time.</param> /// <param name="accessLevel">The new access level for <paramref name="member" />. <see /// cref="AccessLevel.Owner" /> is disallowed.</param> /// <param name="callback">The method to be called when the asynchronous send is /// completed.</param> /// <param name="callbackState">A user provided object that distinguished this send /// from other send requests.</param> /// <returns>An object that represents the asynchronous send request.</returns> public sys.IAsyncResult BeginUpdateFolderMember(string sharedFolderId, MemberSelector member, AccessLevel accessLevel, sys.AsyncCallback callback, object callbackState = null) { var updateFolderMemberArg = new UpdateFolderMemberArg(sharedFolderId, member, accessLevel); return this.BeginUpdateFolderMember(updateFolderMemberArg, callback, callbackState); }
/// <summary> /// <para>Begins an asynchronous send to the remove folder member route.</para> /// </summary> /// <param name="sharedFolderId">The ID for the shared folder.</param> /// <param name="member">The member to remove from the folder. Only the <see /// cref="MemberSelector.DropboxId" /> may be set at this time.</param> /// <param name="leaveACopy">If true, the removed user will keep their copy of the /// folder after it's unshared, assuming it was mounted. Otherwise, it will be removed /// from their Dropbox. Also, this must be set to false when kicking a group.</param> /// <param name="callback">The method to be called when the asynchronous send is /// completed.</param> /// <param name="callbackState">A user provided object that distinguished this send /// from other send requests.</param> /// <returns>An object that represents the asynchronous send request.</returns> public sys.IAsyncResult BeginRemoveFolderMember(string sharedFolderId, MemberSelector member, bool leaveACopy, sys.AsyncCallback callback, object callbackState = null) { var removeFolderMemberArg = new RemoveFolderMemberArg(sharedFolderId, member, leaveACopy); return this.BeginRemoveFolderMember(removeFolderMemberArg, callback, callbackState); }
/// <summary> /// <para>Allows an owner or editor of a shared folder to update another member's /// permissions.</para> /// <para>Warning: This endpoint is in beta and is subject to minor but possibly /// backwards-incompatible changes.</para> /// </summary> /// <param name="sharedFolderId">The ID for the shared folder.</param> /// <param name="member">The member of the shared folder to update. Only the <see /// cref="MemberSelector.DropboxId" /> may be set at this time.</param> /// <param name="accessLevel">The new access level for <paramref name="member" />. <see /// cref="AccessLevel.Owner" /> is disallowed.</param> /// <returns>The task that represents the asynchronous send operation.</returns> /// <exception cref="Dropbox.Api.ApiException{UpdateFolderMemberError}">Thrown if there /// is an error processing the request; This will contain a <see /// cref="UpdateFolderMemberError"/>.</exception> public t.Task UpdateFolderMemberAsync(string sharedFolderId, MemberSelector member, AccessLevel accessLevel) { var updateFolderMemberArg = new UpdateFolderMemberArg(sharedFolderId, member, accessLevel); return this.UpdateFolderMemberAsync(updateFolderMemberArg); }
/// <summary> /// <para>Allows an owner or editor (if the ACL update policy allows) of a shared /// folder to remove another member.</para> /// <para>Warning: This endpoint is in beta and is subject to minor but possibly /// backwards-incompatible changes.</para> /// </summary> /// <param name="sharedFolderId">The ID for the shared folder.</param> /// <param name="member">The member to remove from the folder. Only the <see /// cref="MemberSelector.DropboxId" /> may be set at this time.</param> /// <param name="leaveACopy">If true, the removed user will keep their copy of the /// folder after it's unshared, assuming it was mounted. Otherwise, it will be removed /// from their Dropbox. Also, this must be set to false when kicking a group.</param> /// <returns>The task that represents the asynchronous send operation. The TResult /// parameter contains the response from the server.</returns> /// <exception cref="Dropbox.Api.ApiException{RemoveFolderMemberError}">Thrown if there /// is an error processing the request; This will contain a <see /// cref="RemoveFolderMemberError"/>.</exception> public t.Task<Async.LaunchEmptyResult> RemoveFolderMemberAsync(string sharedFolderId, MemberSelector member, bool leaveACopy) { var removeFolderMemberArg = new RemoveFolderMemberArg(sharedFolderId, member, leaveACopy); return this.RemoveFolderMemberAsync(removeFolderMemberArg); }
/// <summary> /// Pass the <see cref="MemberInfo"/> directly. /// </summary> /// <typeparam name="T">The <see cref="MemberInfo"/> type.</typeparam> /// <param name="memberSelector">The <see cref="MemberSelector{T}"/>.</param> /// <param name="member">The <see cref="MemberInfo"/>.</param> public static void ByMemberInfo <T>( this MemberSelector <T> memberSelector, T member) where T : MemberInfo => memberSelector.Member = new[] { member };
/// <summary> /// Gets the <see cref="MemberInfo"/> using /// the name for the <see cref="Type"/>. /// </summary> /// <typeparam name="T">The type of <see cref="MemberInfo"/> to retrieve.</typeparam> /// <typeparam name="TTarget">The type the member belongs to.</typeparam> /// <param name="memberSelector">The <see cref="MemberSelector{T}"/>.</param> /// <param name="memberName">The name of the member.</param> public static void ByNameForType <T, TTarget>( this MemberSelector <T> memberSelector, string memberName) where T : MemberInfo => memberSelector.ByNameForType(typeof(TTarget), memberName);
/// <summary> /// Gets the <see cref="MemberInfo"/> using a lambda expression /// as a template. The lambda is never invoked and is inspected /// to find the matching type. /// </summary> /// <typeparam name="T">The type of <see cref="MemberInfo"/> to retrieve.</typeparam> /// <typeparam name="TTarget">The type the expression uses as a template.</typeparam> /// <param name="memberSelector">The <see cref="MemberSelector{T}"/>.</param> /// <param name="resolver">The expression template.</param> public static void ByResolver <T, TTarget>( this MemberSelector <T> memberSelector, Expression <Func <TTarget, object> > resolver) where T : MemberInfo => Resolve <T, TTarget>(memberSelector, resolver);
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) { return(MemberSelector.Parse((string)value)); }