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));
}
