diff --git a/src/CLIParser/ArgumentMetadata.cs b/src/CLIParser/ArgumentMetadata.cs
index 1cfac07..0e9bbe7 100644
--- a/src/CLIParser/ArgumentMetadata.cs
+++ b/src/CLIParser/ArgumentMetadata.cs
@@ -35,23 +35,23 @@ namespace MASES.CLIParser
     public enum ArgumentPrefix
     {
         /// <summary>
-        /// Represent an argument without a prefix
+        /// Represents an argument without a prefix
         /// </summary>
         None = 0x0,
         /// <summary>
-        /// Represent a "-"
+        /// Represents a "-"
         /// </summary>
         Dash = 0x1,
         /// <summary>
-        /// Represent a "--"
+        /// Represents a "--"
         /// </summary>
         DoubleDash = 0x2,
         /// <summary>
-        /// Represent a "/"
+        /// Represents a "/"
         /// </summary>
         Slash = 0x4,
         /// <summary>
-        /// Represent a custom prefix
+        /// Represents a custom prefix
         /// </summary>
         Custom = 0x8,
     }
@@ -69,7 +69,7 @@ public enum ArgumentType
         /// </summary>
         KeyValue,
         /// <summary>
-        /// Reperesent an argument whose value if the next argument
+        /// Represents an argument whose value if the next argument
         /// </summary>
         Double
     }
@@ -83,11 +83,11 @@ public enum ArgumentValueType
         /// </summary>
         Free,
         /// <summary>
-        /// Represent a possible value into an array
+        /// Represents a possible value into an array
         /// </summary>
         Array,
         /// <summary>
-        /// Represent a range of values
+        /// Represents a range of values
         /// </summary>
         Range
     }
@@ -169,10 +169,14 @@ public interface IArgumentMetadata
         /// </summary>
         object MinValue { get; set; }
         /// <summary>
-        /// The ,aximum value for the argument if <see cref="ValueType"/> is <see cref="ArgumentValueType.Range"/>
+        /// The maximum value for the argument if <see cref="ValueType"/> is <see cref="ArgumentValueType.Range"/>
         /// </summary>
         object MaxValue { get; set; }
         /// <summary>
+        /// An <see cref="Action"/> to cross check multiple values. If something is not correct during check an <see cref="ArgumentException"/> shall be raised.
+        /// </summary>
+        Action<IEnumerable<IArgumentMetadataParsed>> CrossCheck { get; set; }
+        /// <summary>
         /// The <see cref="Type"/> of the parameter.
         /// </summary>
         Type DataType { get; }
@@ -291,6 +295,8 @@ internal ArgumentMetadataBase()
         /// <inheritdoc/>
         public virtual object MaxValue { get; set; }
         /// <inheritdoc/>
+        public virtual Action<IEnumerable<IArgumentMetadataParsed>> CrossCheck { get; set; }
+        /// <inheritdoc/>
         public virtual Type DataType { get; protected set; }
     }
 
@@ -316,6 +322,7 @@ public ArgumentMetadataParsed(IArgumentMetadata reference)
             ArrayValues = reference.ArrayValues;
             MinValue = reference.MinValue;
             MaxValue = reference.MaxValue;
+            CrossCheck = reference.CrossCheck;
             DataType = reference.DataType;
         }
 
diff --git a/src/CLIParser/CLIParser.cs b/src/CLIParser/CLIParser.cs
index adedb36..c3a91f6 100644
--- a/src/CLIParser/CLIParser.cs
+++ b/src/CLIParser/CLIParser.cs
@@ -310,6 +310,10 @@ public static Parser CreateInstance(Settings settings = null)
         /// </summary>
         public Settings Settings { get; private set; }
         /// <summary>
+        /// The arguments in command-line not parsed, i.e. the possible extra arguments to be used from the application for other scopes
+        /// </summary>
+        public string[] UnparsedArgs { get; private set; }
+        /// <summary>
         /// Available <see cref="IArgumentMetadata"/> for parsing
         /// </summary>
         public IReadOnlyList<IArgumentMetadata> Arguments { get { return new List<IArgumentMetadata>(arguments.Values); } }
@@ -378,6 +382,16 @@ public IEnumerable<IArgumentMetadataParsed> Parse(string[] args)
                 throw new ArgumentException(string.Format("Parameter{0} {1} are not managed", lstArgs.Count == 1 ? string.Empty : "s", string.Join(", ", lstArgs)));
             }
 
+            foreach (var item in parsedArgs.Values)
+            {
+                if (item.CrossCheck != null)
+                {
+                    item.CrossCheck(parsedArgs.Values);
+                }
+            }
+
+            UnparsedArgs = new List<string>(lstArgs).ToArray();
+
             return parsedArgs.Values;
         }
 
diff --git a/src/CLIParser/CLIParser.csproj b/src/CLIParser/CLIParser.csproj
index cd0d2a3..bc62c54 100644
--- a/src/CLIParser/CLIParser.csproj
+++ b/src/CLIParser/CLIParser.csproj
@@ -8,7 +8,7 @@
     <Owners>MASES s.r.l.</Owners>
     <Authors>MASES s.r.l.</Authors>
     <Company>MASES s.r.l.</Company>
-    <Version>2.1.2.0</Version>
+    <Version>2.2.0.0</Version>
     <Product>CLIParser</Product>
     <GenerateAssemblyInfo>true</GenerateAssemblyInfo>
     <TargetFrameworks>net461;netcoreapp3.1;net5.0;net5.0-windows</TargetFrameworks>
@@ -28,6 +28,14 @@
     <SignAssembly>true</SignAssembly>
     <AssemblyOriginatorKeyFile>..\Common\CLIParser.snk</AssemblyOriginatorKeyFile>
   </PropertyGroup>
+  <!-- Fix start https://github.com/dotnet/sourcelink/issues/572 -->
+  <PropertyGroup>
+    <TargetFrameworkMonikerAssemblyAttributesPath>$([System.IO.Path]::Combine('$(IntermediateOutputPath)','$(TargetFrameworkMoniker).AssemblyAttributes$(DefaultLanguageSourceExtension)'))</TargetFrameworkMonikerAssemblyAttributesPath>
+  </PropertyGroup>
+  <ItemGroup>
+    <EmbeddedFiles Include="$(GeneratedAssemblyInfoFile)"/>
+  </ItemGroup>
+  <!-- Fix end -->
   <PropertyGroup Condition="'$(GITHUB_ACTIONS)' == 'true'">
     <ContinuousIntegrationBuild>true</ContinuousIntegrationBuild>
   </PropertyGroup>
diff --git a/tests/CLIParserTest/CLIParserTest.csproj b/tests/CLIParserTest/CLIParserTest.csproj
index aa0a851..73433e4 100644
--- a/tests/CLIParserTest/CLIParserTest.csproj
+++ b/tests/CLIParserTest/CLIParserTest.csproj
@@ -9,7 +9,7 @@
     <Copyright>Copyright ©  MASES s.r.l. 2021</Copyright>
     <Authors>MASES s.r.l.</Authors>
     <Company>MASES s.r.l.</Company>
-    <Version>2.1.2.0</Version>
+    <Version>2.2.0.0</Version>
     <TargetFrameworks>net461;netcoreapp3.1;net5.0;net5.0-windows</TargetFrameworks>
     <OutputPath>..\..\bin\</OutputPath>
   </PropertyGroup>
diff --git a/tests/CLIParserTest/Program.cs b/tests/CLIParserTest/Program.cs
index 9539bd3..63fa378 100644
--- a/tests/CLIParserTest/Program.cs
+++ b/tests/CLIParserTest/Program.cs
@@ -24,6 +24,7 @@
 
 using MASES.CLIParser;
 using System;
+using System.Collections.Generic;
 
 namespace MASES.CLIParserTest
 {
@@ -37,88 +38,101 @@ public enum MyValues
             Third = 0x4
         };
 
+        static void crossCheckExample(IEnumerable<IArgumentMetadataParsed> args)
+        {
+            if (!args.Exist("range")) throw new ArgumentException("range is mandatory for test.");
+        }
+
         static void Main(string[] args)
         {
-            Parser parser = Parser.CreateInstance(new Settings()
+            try
             {
-                CheckUnwanted = false
-            });
+                Parser parser = Parser.CreateInstance(new Settings()
+                {
+                    CheckUnwanted = false
+                });
 
-            new ArgumentMetadata<MyValues>(parser)
-            {
-                Name = "enum",
-                Default = MyValues.First,
-                Help = "this is an enum test",
-                Type = ArgumentType.Double,
-            }.Add();
-            parser.Add(new ArgumentMetadata<bool>()
-            {
-                Name = "test",
-                ShortName = "tst",
-                Help = "this is a test",
-                Type = ArgumentType.Double,
-                ValueType = ArgumentValueType.Free,
-            });
-            parser.Add(new ArgumentMetadata<int>(parser)
-            {
-                Name = "range",
-                Default = 9,
-                Type = ArgumentType.Double,
-                ValueType = ArgumentValueType.Range,
-                MinValue = 2,
-                MaxValue = 10,
-            });
-            parser.Add(new ArgumentMetadata<string>(parser)
-            {
-                Name = "multivalue",
-                Type = ArgumentType.Double,
-                IsMultiValue = true,
-                Default = new string[] { "a", "b" }
-            });
-            parser.Add(new ArgumentMetadata<string>(parser)
-            {
-                Name = "myval",
-                Type = ArgumentType.Single,
-            });
-            parser.Add(new ArgumentMetadata<string>(parser)
-            {
-                Name = "MyParam",
-                Type = ArgumentType.Double,
-            });
-            parser.Add(new ArgumentMetadata<string>(parser)
-            {
-                Name = "MyParam2",
-                Type = ArgumentType.Double,
-            });
+                new ArgumentMetadata<MyValues>(parser)
+                {
+                    Name = "enum",
+                    Default = MyValues.First,
+                    Help = "this is an enum test",
+                    Type = ArgumentType.Double,
+                }.Add();
+                parser.Add(new ArgumentMetadata<bool>()
+                {
+                    Name = "test",
+                    ShortName = "tst",
+                    Help = "this is a test",
+                    Type = ArgumentType.Double,
+                    CrossCheck = crossCheckExample,
+                    ValueType = ArgumentValueType.Free,
+                });
+                parser.Add(new ArgumentMetadata<int>(parser)
+                {
+                    Name = "range",
+                    Default = 9,
+                    Type = ArgumentType.Double,
+                    ValueType = ArgumentValueType.Range,
+                    MinValue = 2,
+                    MaxValue = 10,
+                });
+                parser.Add(new ArgumentMetadata<string>(parser)
+                {
+                    Name = "multivalue",
+                    Type = ArgumentType.Double,
+                    IsMultiValue = true,
+                    Default = new string[] { "a", "b" }
+                });
+                parser.Add(new ArgumentMetadata<string>(parser)
+                {
+                    Name = "myval",
+                    Type = ArgumentType.Single,
+                });
+                parser.Add(new ArgumentMetadata<string>(parser)
+                {
+                    Name = "MyParam",
+                    Type = ArgumentType.Double,
+                });
+                parser.Add(new ArgumentMetadata<string>(parser)
+                {
+                    Name = "MyParam2",
+                    Type = ArgumentType.Double,
+                });
 
-            var result = parser.Parse(args);
+                var result = parser.Parse(args);
 
-            var fileInfo = parser.FromFile(result);
+                var fileInfo = parser.FromFile(result);
 
-            parser.Override(result, fileInfo);
+                parser.Override(result, fileInfo);
 
-            var noFile = parser.RemoveFile(result);
+                var noFile = parser.RemoveFile(result);
 
-            foreach (var item in parser.Exists(noFile))
-            {
-                if (item.Name == "enum")
+                foreach (var item in parser.Exists(noFile))
                 {
-                    Console.WriteLine("Testing method extension: {0} is {1}", item.Name, item.Get<MyValues>());
-                }
+                    if (item.Name == "enum")
+                    {
+                        Console.WriteLine("Testing method extension: {0} is {1}", item.Name, item.Get<MyValues>());
+                    }
 
-                if (!item.IsMultiValue)
-                {
-                    Console.WriteLine("{0} is {1}", item.Name, item.Value);
+                    if (!item.IsMultiValue)
+                    {
+                        Console.WriteLine("{0} is {1}", item.Name, item.Value);
+                    }
+                    else
+                    {
+                        Console.WriteLine("{0} is {1}", item.Name, string.Join(", ", (object[])item.Value));
+                    }
                 }
-                else
+
+                foreach (var item in parser.NotExists(noFile))
                 {
-                    Console.WriteLine("{0} is {1}", item.Name, string.Join(", ", (object[])item.Value));
+                    Console.WriteLine("{0} not exist", item.Name);
                 }
             }
-
-            foreach (var item in parser.NotExists(noFile))
+            catch (Exception e)
             {
-                Console.WriteLine("{0} not exist", item.Name);
+                Console.WriteLine(e.Message);
             }
         }
     }