diff --git a/.gitignore b/.gitignore
index 7508c6d..313797d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -349,3 +349,5 @@ MigrationBackup/
 # Ionide (cross platform F# VS Code tools) working folder
 .ionide/
 /tests/ProxyInterfaceSourceGeneratorTests/Destination/Disposable/*.g.cs
+
+.idea/.idea.ProxyInterfaceSourceGenerator Solution/.idea/
diff --git a/src-examples/ProxyInterfaceConsumer/Address.cs b/src-examples/ProxyInterfaceConsumer/Address.cs
index c9e80b8..f440fc2 100644
--- a/src-examples/ProxyInterfaceConsumer/Address.cs
+++ b/src-examples/ProxyInterfaceConsumer/Address.cs
@@ -7,5 +7,10 @@ namespace ProxyInterfaceConsumer
         public int HouseNumber { get; set; }
 
         public event EventHandler<EventArgs> MyEvent;
+        public int Weird { get; set; }
+        public int Weird2()
+        {
+            return 0;
+        }
     }
 }
\ No newline at end of file
diff --git a/src-examples/ProxyInterfaceConsumer/IAddress.cs b/src-examples/ProxyInterfaceConsumer/IAddress.cs
index f7e3242..ba32668 100644
--- a/src-examples/ProxyInterfaceConsumer/IAddress.cs
+++ b/src-examples/ProxyInterfaceConsumer/IAddress.cs
@@ -1,7 +1,13 @@
+using ProxyInterfaceGenerator;
+
 namespace ProxyInterfaceConsumer
 {
-    [ProxyInterfaceGenerator.Proxy(typeof(Address))]
+    [Proxy(typeof(Address), false, ProxyClassAccessibility.Public, new []{"Weird"})]
     public partial interface IAddress
     {
+        public void Weird()
+        {
+            _Instance.Weird2();
+        }
     }
 }
\ No newline at end of file
diff --git a/src-examples/ProxyInterfaceConsumerForPnP/Program.cs b/src-examples/ProxyInterfaceConsumerForPnP/Program.cs
index 5fbba12..b5ee24a 100644
--- a/src-examples/ProxyInterfaceConsumerForPnP/Program.cs
+++ b/src-examples/ProxyInterfaceConsumerForPnP/Program.cs
@@ -28,7 +28,7 @@ public class Program
 
             IClientContext cp = new ClientContextProxy(clientContext);
 
-            cp.Load<IWeb, Web>(cp.Web, w => w.Lists, w => w.Language, w => w.Author);
+            cp.Load<ProxyInterfaceConsumerForPnP.Interfaces.IWeb, Web>(cp.Web, w => w.Lists, w => w.Language, w => w.Author);
 
             await cp.ExecuteQueryRetryAsync();
 
diff --git a/src-examples/ProxyInterfaceConsumerViaNuGet/IPerson.cs b/src-examples/ProxyInterfaceConsumerViaNuGet/IPerson.cs
index 2969bc2..f6f5b19 100644
--- a/src-examples/ProxyInterfaceConsumerViaNuGet/IPerson.cs
+++ b/src-examples/ProxyInterfaceConsumerViaNuGet/IPerson.cs
@@ -1,6 +1,8 @@
+using ProxyInterfaceGenerator;
+
 namespace ProxyInterfaceConsumer
 {
-    [ProxyInterfaceGenerator.Proxy(typeof(ProxyInterfaceConsumer.Person), ProxyClassAccessibility.Internal))]
+    [Proxy(typeof(Person), ProxyClassAccessibility.Internal)]
     public partial interface IPerson
     {
     }
diff --git a/src-examples/ProxyInterfaceConsumerViaNuGet/Person.cs b/src-examples/ProxyInterfaceConsumerViaNuGet/Person.cs
index b21a785..b999002 100644
--- a/src-examples/ProxyInterfaceConsumerViaNuGet/Person.cs
+++ b/src-examples/ProxyInterfaceConsumerViaNuGet/Person.cs
@@ -52,7 +52,7 @@ namespace ProxyInterfaceConsumer
             b = 1;
         }
 
-        public int In_Out_Ref2(in Address a, out Address b, ref Address c)
+        public int In_Out_Ref2(in IAddress a, out Address b, ref IAddress c)
         {
             b = new Address();
             return 404;
diff --git a/src/ProxyInterfaceSourceGenerator/FileGenerators/ExtraFilesGenerator.cs b/src/ProxyInterfaceSourceGenerator/FileGenerators/ExtraFilesGenerator.cs
index 32f7a13..eb8fb9b 100644
--- a/src/ProxyInterfaceSourceGenerator/FileGenerators/ExtraFilesGenerator.cs
+++ b/src/ProxyInterfaceSourceGenerator/FileGenerators/ExtraFilesGenerator.cs
@@ -27,6 +27,7 @@ namespace ProxyInterfaceGenerator
         public Type Type {{ get; }}
         public bool ProxyBaseClasses {{ get; }}
         public ProxyClassAccessibility Accessibility {{ get; }}
+        public string[] MembersToIgnore {{ get; }}
 
         public ProxyAttribute(Type type) : this(type, false, ProxyClassAccessibility.Public)
         {{
@@ -40,11 +41,16 @@ namespace ProxyInterfaceGenerator
         {{
         }}
 
-        public ProxyAttribute(Type type, bool proxyBaseClasses, ProxyClassAccessibility accessibility)
+        public ProxyAttribute(Type type, bool proxyBaseClasses, ProxyClassAccessibility accessibility) : this(type, proxyBaseClasses, accessibility, Array.Empty<string>())
+        {{
+        }}
+
+        public ProxyAttribute(Type type, bool proxyBaseClasses, ProxyClassAccessibility accessibility, string[] membersToIgnore)
         {{
             Type = type;
             ProxyBaseClasses = proxyBaseClasses;
             Accessibility = accessibility;
+            MembersToIgnore = membersToIgnore;
         }}
     }}
 
diff --git a/src/ProxyInterfaceSourceGenerator/FileGenerators/PartialInterfacesGenerator.cs b/src/ProxyInterfaceSourceGenerator/FileGenerators/PartialInterfacesGenerator.cs
index 27f7c65..c4c7448 100644
--- a/src/ProxyInterfaceSourceGenerator/FileGenerators/PartialInterfacesGenerator.cs
+++ b/src/ProxyInterfaceSourceGenerator/FileGenerators/PartialInterfacesGenerator.cs
@@ -64,9 +64,9 @@ internal class PartialInterfacesGenerator : BaseGenerator, IFilesGenerator
         var implements = implementedInterfacesNames.Any() ? $" : {string.Join(", ", implementedInterfacesNames)}" : string.Empty;
         var @new = extendsProxyClasses.Any() ? "new " : string.Empty;
         var (namespaceStart, namespaceEnd) = NamespaceBuilder.Build(ns);
-        var events = GenerateEvents(classSymbol, proxyData.ProxyBaseClasses);
-        var properties = GenerateProperties(classSymbol, proxyData.ProxyBaseClasses);
-        var methods = GenerateMethods(classSymbol, proxyData.ProxyBaseClasses).TrimEnd();
+        var events = GenerateEvents(classSymbol, proxyData);
+        var properties = GenerateProperties(classSymbol, proxyData);
+        var methods = GenerateMethods(classSymbol, proxyData).TrimEnd();
 
         return $@"//----------------------------------------------------------------------------------------
 // <auto-generated>
@@ -109,11 +109,11 @@ methods}
         return t => !hashSet.Contains(t.Name);
     }
 
-    private string GenerateProperties(ClassSymbol targetClassSymbol, bool proxyBaseClasses)
+    private string GenerateProperties(ClassSymbol targetClassSymbol, ProxyData proxyData)
     {
         var str = new StringBuilder();
 
-        foreach (var property in MemberHelper.GetPublicProperties(targetClassSymbol, proxyBaseClasses, InterfaceFilter<IPropertySymbol>()))
+        foreach (var property in MemberHelper.GetPublicProperties(targetClassSymbol, proxyData, InterfaceFilter<IPropertySymbol>()))
         {
             var type = GetPropertyType(property, out var isReplaced);
 
@@ -142,10 +142,10 @@ methods}
         return str.ToString();
     }
 
-    private string GenerateMethods(ClassSymbol targetClassSymbol, bool proxyBaseClasses)
+    private string GenerateMethods(ClassSymbol targetClassSymbol, ProxyData proxyData)
     {
         var str = new StringBuilder();
-        foreach (var method in MemberHelper.GetPublicMethods(targetClassSymbol, proxyBaseClasses, InterfaceFilter<IMethodSymbol>()))
+        foreach (var method in MemberHelper.GetPublicMethods(targetClassSymbol, proxyData, InterfaceFilter<IMethodSymbol>()))
         {
             var methodParameters = GetMethodParameters(method.Parameters, true);
             var whereStatement = GetWhereStatementFromMethod(method);
@@ -162,10 +162,10 @@ methods}
         return str.ToString();
     }
 
-    private string GenerateEvents(ClassSymbol targetClassSymbol, bool proxyBaseClasses)
+    private string GenerateEvents(ClassSymbol targetClassSymbol, ProxyData proxyData)
     {
         var str = new StringBuilder();
-        foreach (var @event in MemberHelper.GetPublicEvents(targetClassSymbol, proxyBaseClasses, InterfaceFilter<IMethodSymbol>()))
+        foreach (var @event in MemberHelper.GetPublicEvents(targetClassSymbol, proxyData, InterfaceFilter<IMethodSymbol>()))
         {
             var ps = @event.First().Parameters.First();
             var type = ps.GetTypeEnum() == TypeEnum.Complex ? GetParameterType(ps, out _) : ps.Type.ToString();
diff --git a/src/ProxyInterfaceSourceGenerator/FileGenerators/ProxyClassesGenerator.cs b/src/ProxyInterfaceSourceGenerator/FileGenerators/ProxyClassesGenerator.cs
index cf8dbf9..58b0cc9 100644
--- a/src/ProxyInterfaceSourceGenerator/FileGenerators/ProxyClassesGenerator.cs
+++ b/src/ProxyInterfaceSourceGenerator/FileGenerators/ProxyClassesGenerator.cs
@@ -76,10 +76,10 @@ internal partial class ProxyClassesGenerator : BaseGenerator, IFilesGenerator
         }
 
         var @abstract = string.Empty; // targetClassSymbol.Symbol.IsAbstract ? "abstract " : string.Empty;
-        var properties = GeneratePublicProperties(targetClassSymbol, pd.ProxyBaseClasses);
-        var methods = GeneratePublicMethods(targetClassSymbol, pd.ProxyBaseClasses);
-        var events = GenerateEvents(targetClassSymbol, pd.ProxyBaseClasses);
-        var operators = GenerateOperators(targetClassSymbol, pd.ProxyBaseClasses);
+        var properties = GeneratePublicProperties(targetClassSymbol, pd);
+        var methods = GeneratePublicMethods(targetClassSymbol, pd);
+        var events = GenerateEvents(targetClassSymbol, pd);
+        var operators = GenerateOperators(targetClassSymbol, pd);
 
         var configurationForMapster = string.Empty;
         if (Context.ReplacedTypes.Count > 0)
@@ -124,11 +124,11 @@ operators}
 {SupportsNullable.IIf("#nullable restore")}";
     }
 
-    private string GeneratePublicProperties(ClassSymbol targetClassSymbol, bool proxyBaseClasses)
+    private string GeneratePublicProperties(ClassSymbol targetClassSymbol, ProxyData proxyData)
     {
         var str = new StringBuilder();
 
-        foreach (var property in MemberHelper.GetPublicProperties(targetClassSymbol, proxyBaseClasses))
+        foreach (var property in MemberHelper.GetPublicProperties(targetClassSymbol, proxyData))
         {
             var type = GetPropertyType(property, out var isReplaced);
 
@@ -190,11 +190,11 @@ operators}
         return str.ToString();
     }
 
-    private string GeneratePublicMethods(ClassSymbol targetClassSymbol, bool proxyBaseClasses)
+    private string GeneratePublicMethods(ClassSymbol targetClassSymbol, ProxyData proxyData)
     {
         var str = new StringBuilder();
 
-        var methods = MemberHelper.GetPublicMethods(targetClassSymbol, proxyBaseClasses);
+        var methods = MemberHelper.GetPublicMethods(targetClassSymbol, proxyData);
 
         foreach (var method in methods)
         {
@@ -305,10 +305,10 @@ operators}
         return str.ToString();
     }
 
-    private string GenerateEvents(ClassSymbol targetClassSymbol, bool proxyBaseClasses)
+    private string GenerateEvents(ClassSymbol targetClassSymbol, ProxyData proxyData)
     {
         var str = new StringBuilder();
-        foreach (var @event in MemberHelper.GetPublicEvents(targetClassSymbol, proxyBaseClasses))
+        foreach (var @event in MemberHelper.GetPublicEvents(targetClassSymbol, proxyData))
         {
             var name = @event.Key.GetSanitizedName();
             var ps = @event.First().Parameters.First();
@@ -337,16 +337,21 @@ operators}
         return str.ToString();
     }
 
-    private string GenerateOperators(ClassSymbol targetClassSymbol, bool proxyBaseClasses)
+    private string GenerateOperators(ClassSymbol targetClassSymbol, ProxyData proxyData)
     {
         var str = new StringBuilder();
-        foreach (var @operator in MemberHelper.GetPublicStaticOperators(targetClassSymbol, proxyBaseClasses))
+        foreach (var @operator in MemberHelper.GetPublicStaticOperators(targetClassSymbol, proxyData))
         {
             foreach (var attribute in @operator.GetAttributesAsList())
             {
                 str.AppendLine($"        {attribute}");
             }
 
+            if (!@operator.Parameters.Any())
+            {
+                continue;
+            }
+
             var parameter = @operator.Parameters.First();
             var proxyClassName = targetClassSymbol.Symbol.ResolveProxyClassName();
 
diff --git a/src/ProxyInterfaceSourceGenerator/Models/ProxyData.cs b/src/ProxyInterfaceSourceGenerator/Models/ProxyData.cs
index 3a4a407..5110cbe 100644
--- a/src/ProxyInterfaceSourceGenerator/Models/ProxyData.cs
+++ b/src/ProxyInterfaceSourceGenerator/Models/ProxyData.cs
@@ -23,17 +23,18 @@ internal class ProxyData
     public bool ProxyBaseClasses { get; }
 
     public ProxyClassAccessibility Accessibility { get; }
+    public string[] MembersToIgnore { get; }
 
     public ProxyData(string @namespace,
-                     string namespaceDot,
-                     string shortInterfaceName,
-                     string fullInterfaceName,
-                     string fullQualifiedTypeName,
-                     string shortMetadataTypeName,
-                     string fullMetadataTypeName,
-                     List<string> usings,
-                     bool proxyBaseClasses,
-                     ProxyClassAccessibility accessibility)
+        string namespaceDot,
+        string shortInterfaceName,
+        string fullInterfaceName,
+        string fullQualifiedTypeName,
+        string shortMetadataTypeName,
+        string fullMetadataTypeName,
+        List<string> usings,
+        bool proxyBaseClasses,
+        ProxyClassAccessibility accessibility, string[] membersToIgnore)
     {
         Namespace = @namespace ?? throw new ArgumentNullException(nameof(@namespace));
         NamespaceDot = namespaceDot ?? throw new ArgumentNullException(nameof(namespaceDot));
@@ -45,5 +46,6 @@ internal class ProxyData
         Usings = usings ?? throw new ArgumentNullException(nameof(usings));
         ProxyBaseClasses = proxyBaseClasses;
         Accessibility = accessibility;
+        MembersToIgnore = membersToIgnore;
     }
 }
\ No newline at end of file
diff --git a/src/ProxyInterfaceSourceGenerator/SyntaxReceiver/AttributeArgumentListParser.cs b/src/ProxyInterfaceSourceGenerator/SyntaxReceiver/AttributeArgumentListParser.cs
index a8fafcf..52b5eae 100644
--- a/src/ProxyInterfaceSourceGenerator/SyntaxReceiver/AttributeArgumentListParser.cs
+++ b/src/ProxyInterfaceSourceGenerator/SyntaxReceiver/AttributeArgumentListParser.cs
@@ -12,9 +12,9 @@ internal static class AttributeArgumentListParser
 {
     public static ProxyInterfaceGeneratorAttributeArguments ParseAttributeArguments(AttributeArgumentListSyntax? argumentList, SemanticModel semanticModel)
     {
-        if (argumentList is null || argumentList.Arguments.Count is < 1 or > 3)
+        if (argumentList is null || argumentList.Arguments.Count is < 1 or > 4)
         {
-            throw new ArgumentException("The ProxyAttribute requires 1, 2 or 3 arguments.");
+            throw new ArgumentException("The ProxyAttribute requires 1, 2, 3 or 4 arguments.");
         }
 
         ProxyInterfaceGeneratorAttributeArguments result;
@@ -29,6 +29,11 @@ internal static class AttributeArgumentListParser
 
         foreach (var argument in argumentList.Arguments.Skip(1))
         {
+            if (TryParseAsStringArray(argument.Expression, out var membersToIgnore))
+            {
+                result = result with { MembersToIgnore = membersToIgnore };
+                continue;
+            }
             if (TryParseAsBoolean(argument.Expression, out var proxyBaseClasses))
             {
                 result = result with { ProxyBaseClasses = proxyBaseClasses };
@@ -87,4 +92,23 @@ internal static class AttributeArgumentListParser
         value = default;
         return false;
     }
+
+    private static bool TryParseAsStringArray(ExpressionSyntax expressionSyntax, out string[] value)
+    {
+        if (expressionSyntax is ImplicitArrayCreationExpressionSyntax lmplicitArrayCreationExpressionSyntax)
+        {
+            var strings = new List<string>();
+            foreach (var expression in lmplicitArrayCreationExpressionSyntax.Initializer.Expressions)
+            {
+                if (expression.GetFirstToken().Value is string s)
+                {
+                    strings.Add(s);
+                }
+            }
+            value = strings.ToArray();
+            return true;
+        }
+        value = Array.Empty<string>();
+        return false;
+    }
 }
\ No newline at end of file
diff --git a/src/ProxyInterfaceSourceGenerator/SyntaxReceiver/ProxySyntaxReceiver.cs b/src/ProxyInterfaceSourceGenerator/SyntaxReceiver/ProxySyntaxReceiver.cs
index facc5ed..121b340 100644
--- a/src/ProxyInterfaceSourceGenerator/SyntaxReceiver/ProxySyntaxReceiver.cs
+++ b/src/ProxyInterfaceSourceGenerator/SyntaxReceiver/ProxySyntaxReceiver.cs
@@ -77,7 +77,8 @@ internal class ProxySyntaxReceiver : ISyntaxContextReceiver
             shortMetadataTypeName: metadataName.Split('.').Last(),
             usings: usings,
             proxyBaseClasses: fluentBuilderAttributeArguments.ProxyBaseClasses,
-            accessibility: fluentBuilderAttributeArguments.Accessibility
+            accessibility: fluentBuilderAttributeArguments.Accessibility,
+            membersToIgnore: fluentBuilderAttributeArguments.MembersToIgnore
         );
 
         return true;
diff --git a/src/ProxyInterfaceSourceGenerator/Types/FluentBuilderAttributeArguments.cs b/src/ProxyInterfaceSourceGenerator/Types/FluentBuilderAttributeArguments.cs
index 0e4ae9b..b1af428 100644
--- a/src/ProxyInterfaceSourceGenerator/Types/FluentBuilderAttributeArguments.cs
+++ b/src/ProxyInterfaceSourceGenerator/Types/FluentBuilderAttributeArguments.cs
@@ -5,4 +5,5 @@ internal record ProxyInterfaceGeneratorAttributeArguments(string FullyQualifiedD
     public bool ProxyBaseClasses { get; set; }
 
     public ProxyClassAccessibility Accessibility { get; set; }
+    public string[] MembersToIgnore { get; set; } = Array.Empty<string>();
 }
\ No newline at end of file
diff --git a/src/ProxyInterfaceSourceGenerator/Utils/MemberHelper.cs b/src/ProxyInterfaceSourceGenerator/Utils/MemberHelper.cs
index 39236b9..00cce5c 100644
--- a/src/ProxyInterfaceSourceGenerator/Utils/MemberHelper.cs
+++ b/src/ProxyInterfaceSourceGenerator/Utils/MemberHelper.cs
@@ -9,7 +9,7 @@ internal static class MemberHelper
 
     public static IReadOnlyList<IPropertySymbol> GetPublicProperties(
         ClassSymbol classSymbol,
-        bool proxyBaseClasses,
+        ProxyData proxyData,
         params Func<IPropertySymbol, bool>[] filters)
     {
         var allFilters = new List<Func<IPropertySymbol, bool>>(filters)
@@ -17,12 +17,12 @@ internal static class MemberHelper
             p => p.Kind == SymbolKind.Property
         };
 
-        return GetPublicMembers(classSymbol, proxyBaseClasses, allFilters.ToArray()).ToArray();
+        return GetPublicMembers(classSymbol, proxyData, allFilters.ToArray()).ToArray();
     }
 
     public static IReadOnlyList<IMethodSymbol> GetPublicMethods(
         ClassSymbol classSymbol,
-        bool proxyBaseClasses,
+        ProxyData proxyData,
         Func<IMethodSymbol, bool>? filter = null)
     {
         filter ??= _ => true;
@@ -30,7 +30,7 @@ internal static class MemberHelper
         return
             GetPublicMembers(
                 classSymbol,
-                proxyBaseClasses,
+                proxyData,
                 m => m.Kind == SymbolKind.Method,
                 m => m.MethodKind == MethodKind.Ordinary,
                 m => !ExcludedMethods.Contains(m.Name),
@@ -40,7 +40,7 @@ internal static class MemberHelper
 
     public static IReadOnlyList<IMethodSymbol> GetPublicStaticOperators(
         ClassSymbol classSymbol,
-        bool proxyBaseClasses,
+        ProxyData proxyData,
         Func<IMethodSymbol, bool>? filter = null)
     {
         filter ??= _ => true;
@@ -48,7 +48,7 @@ internal static class MemberHelper
         return
             GetPublicMembers(
                     classSymbol,
-                    proxyBaseClasses,
+                    proxyData,
                     m => m.Kind == SymbolKind.Method,
                     m => m.MethodKind == MethodKind.Conversion,
                     m => !ExcludedMethods.Contains(m.Name),
@@ -58,7 +58,7 @@ internal static class MemberHelper
 
     public static IReadOnlyList<IGrouping<ISymbol, IMethodSymbol>> GetPublicEvents(
         ClassSymbol classSymbol,
-        bool proxyBaseClasses,
+        ProxyData proxyData,
         Func<IMethodSymbol, bool>? filter = null)
     {
         filter ??= _ => true;
@@ -67,7 +67,7 @@ internal static class MemberHelper
 #pragma warning disable RS1024 // Compare symbols correctly
         return GetPublicMembers(
                 classSymbol,
-                proxyBaseClasses,
+                proxyData,
                 m => m.MethodKind is MethodKind.EventAdd or MethodKind.EventRemove/* || m.MethodKind == MethodKind.EventRaise*/,
                 filter)
             .GroupBy(e => e.AssociatedSymbol)
@@ -79,14 +79,16 @@ internal static class MemberHelper
     // TODO : do we need also to check for "SanitizedName()" here?
     private static IReadOnlyList<T> GetPublicMembers<T>(
         ClassSymbol classSymbol,
-        bool proxyBaseClasses,
+        ProxyData proxyData,
         params Func<T, bool>[] filters
     ) where T : ISymbol
     {
         var membersQuery = classSymbol.Symbol.GetMembers().OfType<T>()
             .Where(m => m.DeclaredAccessibility == Accessibility.Public);
 
-        foreach (var filter in filters)
+        var f = filters.ToList();
+        f.Add(x => !proxyData.MembersToIgnore.Contains(x.Name));
+        foreach (var filter in f)
         {
             membersQuery = membersQuery.Where(filter);
         }
@@ -94,7 +96,7 @@ internal static class MemberHelper
         var ownMembers = membersQuery.ToList();
         var ownMemberNames = ownMembers.Select(x => x.Name);
 
-        if (!proxyBaseClasses)
+        if (!proxyData.ProxyBaseClasses)
         {
             return ownMembers;
         }
diff --git a/tests/ProxyInterfaceSourceGeneratorTests/ProxyInterfaceSourceGeneratorTest.GenerateFiles_ForClassWithArray_Should_GenerateCorrectFiles.verified.txt b/tests/ProxyInterfaceSourceGeneratorTests/ProxyInterfaceSourceGeneratorTest.GenerateFiles_ForClassWithArray_Should_GenerateCorrectFiles.verified.txt
index 1f66b57..0c9e0a8 100644
--- a/tests/ProxyInterfaceSourceGeneratorTests/ProxyInterfaceSourceGeneratorTest.GenerateFiles_ForClassWithArray_Should_GenerateCorrectFiles.verified.txt
+++ b/tests/ProxyInterfaceSourceGeneratorTests/ProxyInterfaceSourceGeneratorTest.GenerateFiles_ForClassWithArray_Should_GenerateCorrectFiles.verified.txt
@@ -21,6 +21,7 @@ namespace ProxyInterfaceGenerator
         public Type Type { get; }
         public bool ProxyBaseClasses { get; }
         public ProxyClassAccessibility Accessibility { get; }
+        public string[] MembersToIgnore { get; }
 
         public ProxyAttribute(Type type) : this(type, false, ProxyClassAccessibility.Public)
         {
@@ -34,11 +35,16 @@ namespace ProxyInterfaceGenerator
         {
         }
 
-        public ProxyAttribute(Type type, bool proxyBaseClasses, ProxyClassAccessibility accessibility)
+        public ProxyAttribute(Type type, bool proxyBaseClasses, ProxyClassAccessibility accessibility) : this(type, proxyBaseClasses, accessibility, Array.Empty<string>())
+        {
+        }
+
+        public ProxyAttribute(Type type, bool proxyBaseClasses, ProxyClassAccessibility accessibility, string[] membersToIgnore)
         {
             Type = type;
             ProxyBaseClasses = proxyBaseClasses;
             Accessibility = accessibility;
+            MembersToIgnore = membersToIgnore;
         }
     }
 
diff --git a/tests/ProxyInterfaceSourceGeneratorTests/ProxyInterfaceSourceGeneratorTest.GenerateFiles_ForClassWithIgnores.verified.txt b/tests/ProxyInterfaceSourceGeneratorTests/ProxyInterfaceSourceGeneratorTest.GenerateFiles_ForClassWithIgnores.verified.txt
new file mode 100644
index 0000000..c2b7afe
--- /dev/null
+++ b/tests/ProxyInterfaceSourceGeneratorTests/ProxyInterfaceSourceGeneratorTest.GenerateFiles_ForClassWithIgnores.verified.txt
@@ -0,0 +1,140 @@
+[
+  {
+    HintName: ProxyInterfaceGenerator.Extra.g.cs,
+    Source:
+//----------------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by https://github.com/StefH/ProxyInterfaceSourceGenerator.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//----------------------------------------------------------------------------------------
+
+using System;
+
+namespace ProxyInterfaceGenerator
+{
+    [AttributeUsage(AttributeTargets.Interface)]
+    internal sealed class ProxyAttribute : Attribute
+    {
+        public Type Type { get; }
+        public bool ProxyBaseClasses { get; }
+        public ProxyClassAccessibility Accessibility { get; }
+        public string[] MembersToIgnore { get; }
+
+        public ProxyAttribute(Type type) : this(type, false, ProxyClassAccessibility.Public)
+        {
+        }
+
+        public ProxyAttribute(Type type, bool proxyBaseClasses) : this(type, proxyBaseClasses, ProxyClassAccessibility.Public)
+        {
+        }
+
+        public ProxyAttribute(Type type, ProxyClassAccessibility accessibility) : this(type, false, accessibility)
+        {
+        }
+
+        public ProxyAttribute(Type type, bool proxyBaseClasses, ProxyClassAccessibility accessibility) : this(type, proxyBaseClasses, accessibility, Array.Empty<string>())
+        {
+        }
+
+        public ProxyAttribute(Type type, bool proxyBaseClasses, ProxyClassAccessibility accessibility, string[] membersToIgnore)
+        {
+            Type = type;
+            ProxyBaseClasses = proxyBaseClasses;
+            Accessibility = accessibility;
+            MembersToIgnore = membersToIgnore;
+        }
+    }
+
+    [Flags]
+    internal enum ProxyClassAccessibility
+    {
+        Public = 0,
+
+        Internal = 1
+    }
+}
+  },
+  {
+    HintName: ProxyInterfaceSourceGeneratorTests.Source.IFoo2.g.cs,
+    Source:
+//----------------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by https://github.com/StefH/ProxyInterfaceSourceGenerator.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//----------------------------------------------------------------------------------------
+
+#nullable enable
+using System;
+
+namespace ProxyInterfaceSourceGeneratorTests.Source
+{
+    public partial interface IFoo2
+    {
+        global::ProxyInterfaceSourceGeneratorTests.Source.Foo2 _Instance { get; }
+
+        global::ProxyInterfaceSourceGeneratorTests.Source.IFoo2[] Foos { get; set; }
+
+        global::ProxyInterfaceSourceGeneratorTests.Source.IFoo2[] DoSomethingAndGetAnArrayOfFoos();
+
+        int Weird2();
+    }
+}
+#nullable restore
+  },
+  {
+    HintName: ProxyInterfaceSourceGeneratorTests.Source.Foo2Proxy.g.cs,
+    Source:
+//----------------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by https://github.com/StefH/ProxyInterfaceSourceGenerator.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//----------------------------------------------------------------------------------------
+
+#nullable enable
+using System;
+
+namespace ProxyInterfaceSourceGeneratorTests.Source
+{
+    public partial class Foo2Proxy : global::ProxyInterfaceSourceGeneratorTests.Source.IFoo2
+    {
+        public global::ProxyInterfaceSourceGeneratorTests.Source.Foo2 _Instance { get; }
+        
+        public global::ProxyInterfaceSourceGeneratorTests.Source.IFoo2[] Foos { get => Mapster.TypeAdapter.Adapt<global::ProxyInterfaceSourceGeneratorTests.Source.IFoo2[]>(_Instance.Foos); set => _Instance.Foos = Mapster.TypeAdapter.Adapt<ProxyInterfaceSourceGeneratorTests.Source.Foo2[]>(value); }
+
+        public global::ProxyInterfaceSourceGeneratorTests.Source.IFoo2[] DoSomethingAndGetAnArrayOfFoos()
+        {
+            var result_1603865878 = _Instance.DoSomethingAndGetAnArrayOfFoos();
+            return Mapster.TypeAdapter.Adapt<global::ProxyInterfaceSourceGeneratorTests.Source.IFoo2[]>(result_1603865878);
+        }
+
+        public int Weird2()
+        {
+            var result__1602200929 = _Instance.Weird2();
+            return result__1602200929;
+        }
+
+
+        public Foo2Proxy(global::ProxyInterfaceSourceGeneratorTests.Source.Foo2 instance)
+        {
+            _Instance = instance;
+            
+
+            Mapster.TypeAdapterConfig<global::ProxyInterfaceSourceGeneratorTests.Source.Foo2, global::ProxyInterfaceSourceGeneratorTests.Source.IFoo2>.NewConfig().ConstructUsing(instance1325374861 => new global::ProxyInterfaceSourceGeneratorTests.Source.Foo2Proxy(instance1325374861));
+            Mapster.TypeAdapterConfig<global::ProxyInterfaceSourceGeneratorTests.Source.IFoo2, global::ProxyInterfaceSourceGeneratorTests.Source.Foo2>.NewConfig().MapWith(proxy1047178445 => ((global::ProxyInterfaceSourceGeneratorTests.Source.Foo2Proxy) proxy1047178445)._Instance);
+
+
+        }
+    }
+}
+#nullable restore
+  }
+]
\ No newline at end of file
diff --git a/tests/ProxyInterfaceSourceGeneratorTests/ProxyInterfaceSourceGeneratorTest.cs b/tests/ProxyInterfaceSourceGeneratorTests/ProxyInterfaceSourceGeneratorTest.cs
index 1a1f749..79d4467 100644
--- a/tests/ProxyInterfaceSourceGeneratorTests/ProxyInterfaceSourceGeneratorTest.cs
+++ b/tests/ProxyInterfaceSourceGeneratorTests/ProxyInterfaceSourceGeneratorTest.cs
@@ -86,6 +86,48 @@ public class ProxyInterfaceSourceGeneratorTest
         return Verify(results);
     }
 
+
+    [Fact]
+    public Task GenerateFiles_ForClassWithIgnores()
+    {
+        // Arrange
+        var fileNames = new[]
+        {
+            "ProxyInterfaceSourceGeneratorTests.Source.IFoo2.g.cs",
+            "ProxyInterfaceSourceGeneratorTests.Source.Foo2Proxy.g.cs"
+        };
+
+        var path = "./Source/IFoo2.cs";
+        var sourceFile = new SourceFile
+        {
+            Path = path,
+            Text = File.ReadAllText(path),
+            AttributeToAddToInterface = new ExtraAttribute
+            {
+                Name = "ProxyInterfaceGenerator.Proxy",
+                ArgumentList = new []
+                {
+                    "typeof(ProxyInterfaceSourceGeneratorTests.Source.Foo2)", "false", "ProxyClassAccessibility.Public",
+                    "new []{\"Weird\",\"NotHere\"}"
+                }
+            }
+        };
+
+        // Act
+        var result = _sut.Execute(new[]
+        {
+            sourceFile
+        });
+
+        // Assert
+        result.Valid.Should().BeTrue();
+        result.Files.Should().HaveCount(fileNames.Length + 1);
+
+        // Verify
+        var results = result.GeneratorDriver.GetRunResult().Results.First().GeneratedSources;
+        return Verify(results);
+    }
+
     [Fact]
     public void GenerateFiles_ForGenericType_Should_GenerateCorrectFiles()
     {
diff --git a/tests/ProxyInterfaceSourceGeneratorTests/ProxyInterfaceSourceGeneratorTests.csproj b/tests/ProxyInterfaceSourceGeneratorTests/ProxyInterfaceSourceGeneratorTests.csproj
index 5acaa96..6266499 100644
--- a/tests/ProxyInterfaceSourceGeneratorTests/ProxyInterfaceSourceGeneratorTests.csproj
+++ b/tests/ProxyInterfaceSourceGeneratorTests/ProxyInterfaceSourceGeneratorTests.csproj
@@ -49,6 +49,12 @@
         <Compile Update="Source\AkkaActor\*.cs">
             <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
         </Compile>
+        <Compile Update="Source\Foo2.cs">
+          <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+        </Compile>
+        <Compile Update="Source\IFoo2.cs">
+          <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+        </Compile>
     </ItemGroup>
 
     <ItemGroup>
diff --git a/tests/ProxyInterfaceSourceGeneratorTests/Source/Foo2.cs b/tests/ProxyInterfaceSourceGeneratorTests/Source/Foo2.cs
new file mode 100644
index 0000000..01dfeb8
--- /dev/null
+++ b/tests/ProxyInterfaceSourceGeneratorTests/Source/Foo2.cs
@@ -0,0 +1,36 @@
+namespace ProxyInterfaceSourceGeneratorTests.Source;
+
+public class Foo2
+{
+    //public Bar DoSomethingAndGetABar()
+    //{
+    //    return new Bar();
+    //}
+
+    //public Bar[] DoSomethingAndGetAnArrayOfBars()
+    //{
+    //    return new[] { new Bar() };
+    //}
+
+    //public Foo DoSomethingAndGetAFoo()
+    //{
+    //    return new Foo();
+    //}
+
+    public Foo2[] Foos { get; set; }
+
+    public Foo2[] DoSomethingAndGetAnArrayOfFoos()
+    {
+        return new[] { new Foo2() };
+    }
+    public int Weird { get; set; }
+    public int Weird2()
+    {
+        return 0;
+    }
+
+    //public List<Foo> DoSomethingAndGetAListOfFoos()
+    //{
+    //    return new[] { new Foo() }.ToList();
+    //}
+}
\ No newline at end of file
diff --git a/tests/ProxyInterfaceSourceGeneratorTests/Source/IFoo2.cs b/tests/ProxyInterfaceSourceGeneratorTests/Source/IFoo2.cs
new file mode 100644
index 0000000..c10a3a4
--- /dev/null
+++ b/tests/ProxyInterfaceSourceGeneratorTests/Source/IFoo2.cs
@@ -0,0 +1,6 @@
+namespace ProxyInterfaceSourceGeneratorTests.Source
+{
+    public partial interface IFoo2
+    {
+    }
+}
\ No newline at end of file