/// <summary> /// Checks if the method is public or protected. /// </summary> /// <param name="method"></param> /// <returns></returns> protected bool IsAccessible(MethodBase method) { // Accessibility supported by the full framework and CoreCLR if (method.IsPublic || method.IsFamily || method.IsFamilyOrAssembly) { return(true); } #if !SILVERLIGHT // Accessibility not supported by the CoreCLR if (method.IsFamilyAndAssembly) { return(true); } if (InternalsHelper.IsInternalToDynamicProxy(method.DeclaringType.Assembly) && method.IsAssembly) { return(true); } #endif // Explicitly implemented interface method on class if (method.IsPrivate && method.IsFinal) { Logger.Debug("Excluded explicitly implemented interface method {0} on type {1} because it cannot be intercepted.", method.Name, method.DeclaringType.FullName); } return(false); }
/// <summary> /// Performs some basic screening and invokes the <see cref="IProxyGenerationHook"/> /// to select methods. /// </summary> /// <param name="method"></param> /// <param name="onlyVirtuals"></param> /// <param name="hook"></param> /// <returns></returns> protected bool AcceptMethod(MethodInfo method, bool onlyVirtuals, IProxyGenerationHook hook) { // we can never intercept a sealed (final) method if (method.IsFinal) { Logger.Debug("Excluded sealed method {0} on {1} because it cannot be intercepted.", method.Name, method.DeclaringType.FullName); return(false); } bool isInternalsAndNotVisibleToDynamicProxy = InternalsHelper.IsInternal(method); if (isInternalsAndNotVisibleToDynamicProxy) { isInternalsAndNotVisibleToDynamicProxy = InternalsHelper.IsInternalToDynamicProxy(method.DeclaringType.Assembly) == false; } if (isInternalsAndNotVisibleToDynamicProxy) { return(false); } if (onlyVirtuals && !method.IsVirtual) { #if SILVERLIGHT if (method.DeclaringType != typeof(object)) #else if (method.DeclaringType != typeof(object) && method.DeclaringType != typeof(MarshalByRefObject)) #endif { Logger.Debug("Excluded non-virtual method {0} on {1} because it cannot be intercepted.", method.Name, method.DeclaringType.FullName); hook.NonVirtualMemberNotification(type, method); } return(false); } //can only proxy methods that are public or protected (or internals that have already been checked above) if ((method.IsPublic || method.IsFamily || method.IsAssembly || method.IsFamilyOrAssembly) == false) { return(false); } if (method.DeclaringType == typeof(object)) { return(false); } #if !SILVERLIGHT if (method.DeclaringType == typeof(MarshalByRefObject)) { return(false); } #endif return(hook.ShouldInterceptMethod(type, method)); }
public void GetDefaultFontReturnsAFont() { // Given // When Font font = InternalsHelper.GetDefaultFont(); // Then Assert.IsNotNull(font); }
public void GetUserDataFolderReturnsString() { // Given // When string userDataFolder = InternalsHelper.GetUserDataFolder(); // Then Assert.IsNotNullOrEmpty(userDataFolder); }
private bool IsConstructorVisible(ConstructorInfo constructor) { return(constructor.IsPublic || constructor.IsFamily || constructor.IsFamilyOrAssembly #if !Silverlight || (constructor.IsAssembly && InternalsHelper.IsInternalToDynamicProxy(constructor.DeclaringType.Assembly))); #else ; #endif }
public void GetIdentifierTokenValueTextReturnsNullForInvalidNode() { // Given SyntaxTree syntaxTree = Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText("int c = 0;", InternalsHelper.GetCSharpParseOptionsForSourceCodeKind(SourceCodeKind.Script)); SyntaxNode syntaxNode = syntaxTree.GetRoot(); // The root will never have an identifier token // When string tokenValueText = InternalsHelper.GetIdentifierTokenValueText(syntaxNode); // Then Assert.IsNull(tokenValueText); }
public void GetIdentifierTokenValueTextReturnsTokenValueTextForValidNode() { // Given SyntaxTree syntaxTree = Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText("int c = 0;", InternalsHelper.GetCSharpParseOptionsForSourceCodeKind(SourceCodeKind.Script)); SyntaxToken syntaxToken = syntaxTree.GetRoot() .DescendantNodesAndTokens() .Where(x => x.IsToken) .Select(x => x.AsToken()) .First(x => Microsoft.CodeAnalysis.CSharp.CSharpExtensions.Kind(x) == Microsoft.CodeAnalysis.CSharp.SyntaxKind.IdentifierToken); SyntaxNode syntaxNode = syntaxToken.Parent; // When string tokenValueText = InternalsHelper.GetIdentifierTokenValueText(syntaxNode); // Then Assert.AreEqual("c", tokenValueText); }
private MethodAttributes ObtainAttributes() { var methodInfo = Method; var attributes = MethodAttributes.Virtual; if (methodInfo.IsFinal || Method.DeclaringType.IsInterface) { attributes |= MethodAttributes.NewSlot; } if (methodInfo.IsPublic) { attributes |= MethodAttributes.Public; } if (methodInfo.IsHideBySig) { attributes |= MethodAttributes.HideBySig; } if (InternalsHelper.IsInternal(methodInfo) && InternalsHelper.IsInternalToDynamicProxy(methodInfo.DeclaringType.Assembly)) { attributes |= MethodAttributes.Assembly; } if (methodInfo.IsFamilyAndAssembly) { attributes |= MethodAttributes.FamANDAssem; } else if (methodInfo.IsFamilyOrAssembly) { attributes |= MethodAttributes.FamORAssem; } else if (methodInfo.IsFamily) { attributes |= MethodAttributes.Family; } if (Standalone == false) { attributes |= MethodAttributes.SpecialName; } return(attributes); }
/// <summary> /// Validates that the target type to proxy is visible and not generic. /// </summary> /// <param name="target"> /// The interface type to proxy. /// </param> private static void AssertValidType(Type target) { // This is copied from the DefaultProxyBuilder because we need to // validate types but the validation logic is not accessible. bool isTargetNested = target.IsNested; bool isNestedAndInternal = isTargetNested && (target.IsNestedAssembly || target.IsNestedFamORAssem); bool isInternalNotNested = target.IsVisible == false && isTargetNested == false; bool internalAndVisibleToDynProxy = (isInternalNotNested || isNestedAndInternal) && InternalsHelper.IsInternalToDynamicProxy(target.Assembly); var isAccessible = target.IsPublic || target.IsNestedPublic || internalAndVisibleToDynProxy; if (!isAccessible) { throw new GeneratorException(String.Format(CultureInfo.CurrentUICulture, Resources.DynamicProxy_InterfaceTypeToProxyNotPublic, target.FullName)); } if (target.IsGenericTypeDefinition) { throw new GeneratorException(String.Format(CultureInfo.CurrentUICulture, Resources.DynamicProxy_InterfaceTypeToProxyIsGeneric, target.FullName)); } }
internal static SyntaxTree GetSyntaxTree(Query query) { if (query != null) { switch (query.Language) { case QueryLanguage.Expression: return(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(query.Text, InternalsHelper.GetCSharpParseOptionsForSourceCodeKind(SourceCodeKind.Interactive))); case QueryLanguage.Statements: return(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(query.Text, InternalsHelper.GetCSharpParseOptionsForSourceCodeKind(SourceCodeKind.Script))); case QueryLanguage.Program: return(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(query.Text, InternalsHelper.GetCSharpParseOptionsForSourceCodeKind(SourceCodeKind.Script))); case QueryLanguage.VBExpression: return(Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxTree.ParseText(query.Text, InternalsHelper.GetVisualBasicParseOptionsForSourceCodeKind(SourceCodeKind.Interactive))); case QueryLanguage.VBStatements: return(Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxTree.ParseText(query.Text, InternalsHelper.GetVisualBasicParseOptionsForSourceCodeKind(SourceCodeKind.Script))); case QueryLanguage.VBProgram: return(Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxTree.ParseText(query.Text, InternalsHelper.GetVisualBasicParseOptionsForSourceCodeKind(SourceCodeKind.Script))); default: return(null); } } return(null); }