diff --git a/lang/csharp/src/apache/codegen/AvroGen.cs b/lang/csharp/src/apache/codegen/AvroGen.cs
index 349911754e9..c13053c25e1 100644
--- a/lang/csharp/src/apache/codegen/AvroGen.cs
+++ b/lang/csharp/src/apache/codegen/AvroGen.cs
@@ -1,4 +1,4 @@
-/**
+/*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
@@ -15,15 +15,72 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 using System;
 using System.Collections.Generic;
-using System.Text;
+using System.Linq;
+using System.Text.RegularExpressions;
 
 namespace Avro
 {
-    class AvroGen
+    public static class AvroGen
     {
-        static int Main(string[] args)
+        private static readonly CommandLineArgument _createNamespaceDirectoriesParameter;
+        private static readonly CommandLineArgument _helpParameter;
+        private static readonly CommandLineArgument _namespaceParameter;
+        private static readonly CommandLineArgument _protocolParameter;
+        private static readonly CommandLineArgument _schemaParameter;
+
+        static AvroGen()
+        {
+            // Primary usage parameters
+            _schemaParameter = new CommandLineArgument
+            {
+                Parameter = "-s",
+                FriendlyName = "Schema",
+                Usage = "avrogen -s <schemafile> <outputdir> [--namespace <my.avro.ns:my.csharp.ns>]",
+                IsOptional = false,
+            };
+
+            _protocolParameter = new CommandLineArgument
+            {
+                Parameter = "-p",
+                FriendlyName = "Protocol",
+                Usage = "avrogen -p <protocolfile> <outputdir> [--namespace <my.avro.ns:my.csharp.ns>]",
+                IsOptional = false,
+            };
+
+            // Optional parameters
+            _helpParameter = new CommandLineArgument
+            {
+                Parameter = "-h",
+                Aliases = new List<string>() { "--help" },
+                FriendlyName = "Help",
+                Usage = "Show this screen.",
+                IsOptional = true,
+            };
+
+            _namespaceParameter = new CommandLineArgument
+            {
+                Parameter = "--namespace",
+                FriendlyName = "Namespace",
+                Usage = "Map an Avro schema/protocol namespace to a C# namespace. " +
+                "The format is \"my.avro.namespace:my.csharp.namespace\". " +
+                "May be specified multiple times to map multiple namespaces. ",
+                IsOptional = true,
+            };
+
+            _createNamespaceDirectoriesParameter = new CommandLineArgument
+            {
+                Parameter = "--create-namespace-directories",
+                FriendlyName = "Create Namespace Directories",
+                Usage = "Optional parameter to change how the files are output to the outputdir. " +
+                "Default is set to true. False will output the files to the root of the outputdir",
+                IsOptional = true,
+            };
+        }
+
+        private static int Main(string[] args)
         {
             // Print usage if no arguments provided
             if (args.Length == 0)
@@ -33,164 +90,210 @@ static int Main(string[] args)
             }
 
             // Print usage if help requested
-            if (args[0] == "-h" || args[0] == "--help")
+            if (args.Contains("-h") || args.Contains("--help"))
             {
                 Usage();
                 return 0;
             }
 
-            // Parse command line arguments
-            bool? isProtocol = null;
-            string inputFile = null;
-            string outputDir = null;
-            var namespaceMapping = new Dictionary<string, string>();
-            for (int i = 0; i < args.Length; ++i)
+            try
             {
-                if (args[i] == "-p")
-                {
-                    if (i + 1 >= args.Length)
-                    {
-                        Console.Error.WriteLine("Missing path to protocol file");
-                        Usage();
-                        return 1;
-                    }
-
-                    isProtocol = true;
-                    inputFile = args[++i];
-                }
-                else if (args[i] == "-s")
+                if (args.Contains(_protocolParameter.Parameter))
                 {
-                    if (i + 1 >= args.Length)
-                    {
-                        Console.Error.WriteLine("Missing path to schema file");
-                        Usage();
-                        return 1;
-                    }
-
-                    isProtocol = false;
-                    inputFile = args[++i];
+                    ProtocolArguments protocolArguments = ParseProtocolInput(args);
+                    Generator.GenerateProtocol(protocolArguments);
                 }
-                else if (args[i] == "--namespace")
+
+                if (args.Contains(_schemaParameter.Parameter))
                 {
-                    if (i + 1 >= args.Length)
-                    {
-                        Console.Error.WriteLine("Missing namespace mapping");
-                        Usage();
-                        return 1;
-                    }
-
-                    var parts = args[++i].Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
-                    if (parts.Length != 2)
-                    {
-                        Console.Error.WriteLine("Malformed namespace mapping. Required format is \"avro.namespace:csharp.namespace\"");
-                        Usage();
-                        return 1;
-                    }
-
-                    namespaceMapping[parts[0]] = parts[1];
+                    SchemaArguments schemaArguments = ParseSchemaInput(args);
+                    Generator.GenerateSchema(schemaArguments);
                 }
-                else if (outputDir == null)
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine(ex.ToString());
+                Usage();
+                return 1;
+            }
+
+            return 0;
+        }
+
+        private static void Usage()
+        {
+            Console.WriteLine(
+                $"{AppDomain.CurrentDomain.FriendlyName}\n\n" +
+                "Usage:\n" +
+                $"  {_protocolParameter.Usage}\n" +
+                $"  {_schemaParameter.Usage}\n\n" +
+                "Options:\n" +
+                FormatUsage(_helpParameter) +
+                FormatUsage(_namespaceParameter) +
+                FormatUsage(_createNamespaceDirectoriesParameter)
+                );
+            return;
+        }
+
+        private static string FormatUsage(CommandLineArgument parameter)
+        {
+            // Use the longest parameter.  Add 2 spaces at front and 1 space at the end.
+            int length = _createNamespaceDirectoriesParameter.Parameter.Length + 3;
+
+            string paramWithAliases = parameter.Parameter + " " + string.Join(' ', parameter.Aliases);
+
+            string paramText = $"  {paramWithAliases}{new string(' ', length - paramWithAliases.Length - 2)}";
+
+            List<string> sentences = WordWrap(parameter.Usage, 60).ToList();
+
+            string fullText = paramText;
+
+            for (int i = 0; i < sentences.Count; i++)
+            {
+                // spacing after parameter
+                if (i == 0)
                 {
-                    outputDir = args[i];
+                    fullText += sentences[i] + System.Environment.NewLine;
+                    continue;
                 }
-                else
+
+                // Add sentence on new line
+                fullText += new string(' ', paramText.Length) + sentences[i] + System.Environment.NewLine;
+            }
+
+            return fullText + System.Environment.NewLine;
+        }
+
+        private static (string, string) GetThreePartArgument(string[] args, string option)
+        {
+            IEnumerable<string> arguments = args.SkipWhile(i => i != option).Skip(1).Take(2);
+
+            return (arguments.First(), arguments.Last());
+        }
+
+        private static string GetTwoPartArgument(string[] args, string option)
+            => args.SkipWhile(i => i != option).Skip(1).Take(1).FirstOrDefault();
+
+        private static List<string> GetTwoPartArguments(string[] args, string option)
+        {
+            List<string> arguments = new List<string>();
+            for (int i = 0; i < args.Length; i++)
+            {
+                if (args[i] == option)
                 {
-                    Console.Error.WriteLine("Unexpected command line argument: {0}", args[i]);
-                    Usage();
+                    arguments.Add(args[i + 1]);
+                    i++;
                 }
             }
 
-            // Ensure we got all the command line arguments we need
-            bool isValid = true;
-            int rc = 0;
-            if (!isProtocol.HasValue || inputFile == null)
+            return arguments;
+        }
+
+        private static bool ParseCreateNamespaceDirectories(string[] args)
+        {
+            string createDirectoriesValue = GetTwoPartArgument(args, _createNamespaceDirectoriesParameter.Parameter);
+
+            if (string.IsNullOrWhiteSpace(createDirectoriesValue) |
+                (!createDirectoriesValue.Equals("true", StringComparison.InvariantCultureIgnoreCase) &
+                !createDirectoriesValue.Equals("false", StringComparison.InvariantCultureIgnoreCase)))
             {
-                Console.Error.WriteLine("Must provide either '-p <protocolfile>' or '-s <schemafile>'");
-                isValid = false;
+                throw new AvroException($"{_createNamespaceDirectoriesParameter} parameters must have a value of true or false");
             }
-            else if (outputDir == null)
+
+            return createDirectoriesValue.Equals("true", StringComparison.InvariantCultureIgnoreCase);
+        }
+
+        private static Dictionary<string, string> ParseNamespace(string[] args)
+        {
+            List<string> namespaces = GetTwoPartArguments(args, _namespaceParameter.Parameter);
+
+            if (namespaces.Count == 0)
             {
-                Console.Error.WriteLine("Must provide 'outputdir'");
-                isValid = false;
+                throw new AvroException("Missing namespace mapping");
             }
 
+            Dictionary<string, string> arguments = new Dictionary<string, string>();
 
-            if (!isValid)
+            foreach (string ns in namespaces)
             {
-                Usage();
-                rc = 1;
+                string[] parts = ns.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
+                if (parts.Length != 2)
+                {
+                    Console.Error.WriteLine($"Malformed namespace mapping. Required format is \"avro.namespace:csharp.namespace\" Actual: {ns}");
+                }
+
+                arguments[parts[0]] = parts[1];
             }
-            else if (isProtocol.Value)
-                rc = GenProtocol(inputFile, outputDir, namespaceMapping);
-            else
-                rc = GenSchema(inputFile, outputDir, namespaceMapping);
 
-            return rc;
+            return arguments;
         }
 
-        static void Usage()
+        private static ProtocolArguments ParseProtocolInput(string[] args)
         {
-            Console.WriteLine("{0}\n\n" +
-                "Usage:\n" +
-                "  avrogen -p <protocolfile> <outputdir> [--namespace <my.avro.ns:my.csharp.ns>]\n" +
-                "  avrogen -s <schemafile> <outputdir> [--namespace <my.avro.ns:my.csharp.ns>]\n\n" +
-                "Options:\n" +
-                "  -h --help   Show this screen.\n" +
-                "  --namespace Map an Avro schema/protocol namespace to a C# namespace.\n" +
-                "              The format is \"my.avro.namespace:my.csharp.namespace\".\n" +
-                "              May be specified multiple times to map multiple namespaces.\n",
-                AppDomain.CurrentDomain.FriendlyName);
-            return;
+            ProtocolArguments arguments = new ProtocolArguments();
+
+            (string, string) argument = GetThreePartArgument(args, _protocolParameter.Parameter);
+
+            arguments.ProtocolFile = argument.Item1;
+            arguments.OutputDirectory = argument.Item2;
+
+            if (args.Contains(_namespaceParameter.Parameter))
+            {
+                arguments.NamespaceMapping = ParseNamespace(args);
+            }
+
+            return arguments;
         }
-        static int GenProtocol(string infile, string outdir,
-            IEnumerable<KeyValuePair<string, string>> namespaceMapping)
+
+        private static SchemaArguments ParseSchemaInput(string[] args)
         {
-            try
-            {
-                string text = System.IO.File.ReadAllText(infile);
-                Protocol protocol = Protocol.Parse(text);
+            SchemaArguments arguments = new SchemaArguments();
 
-                CodeGen codegen = new CodeGen();
-                codegen.AddProtocol(protocol);
+            (string, string) argument = GetThreePartArgument(args, _schemaParameter.Parameter);
 
-                foreach (var entry in namespaceMapping)
-                    codegen.NamespaceMapping[entry.Key] = entry.Value;
+            arguments.SchemaFile = argument.Item1;
+            arguments.OutputDirectory = argument.Item2;
 
-                codegen.GenerateCode();
-                codegen.WriteTypes(outdir);
+            if (args.Contains(_namespaceParameter.Parameter))
+            {
+                arguments.NamespaceMapping = ParseNamespace(args);
             }
-            catch (Exception ex)
+
+            if (args.Contains(_createNamespaceDirectoriesParameter.Parameter))
             {
-                Console.Error.WriteLine("Exception occurred. " + ex.Message);
-                return 1;
+                arguments.CreateNamespaceDirectories = ParseCreateNamespaceDirectories(args);
             }
 
-            return 0;
+            return arguments;
         }
-        static int GenSchema(string infile, string outdir,
-            IEnumerable<KeyValuePair<string, string>> namespaceMapping)
+
+        private static IEnumerable<string> WordWrap(string text, int width)
         {
-            try
-            {
-                string text = System.IO.File.ReadAllText(infile);
-                Schema schema = Schema.Parse(text);
+            string forcedBreakZonePattern = @"\n";
+            string normalBreakZonePattern = @"\s+|(?<=[-,.;])|$";
 
-                CodeGen codegen = new CodeGen();
-                codegen.AddSchema(schema);
+            var forcedZones = Regex.Matches(text, forcedBreakZonePattern).Cast<Match>().ToList();
+            var normalZones = Regex.Matches(text, normalBreakZonePattern).Cast<Match>().ToList();
 
-                foreach (var entry in namespaceMapping)
-                    codegen.NamespaceMapping[entry.Key] = entry.Value;
+            int start = 0;
 
-                codegen.GenerateCode();
-                codegen.WriteTypes(outdir);
-            }
-            catch (Exception ex)
+            while (start < text.Length)
             {
-                Console.Error.WriteLine("Exception occurred. " + ex.Message);
-                return 1;
-            }
+                var zone =
+                    forcedZones.Find(z => z.Index >= start && z.Index <= start + width) ??
+                    normalZones.FindLast(z => z.Index >= start && z.Index <= start + width);
 
-            return 0;
+                if (zone == null)
+                {
+                    yield return text.Substring(start, width);
+                    start += width;
+                }
+                else
+                {
+                    yield return text.Substring(start, zone.Index - start);
+                    start = zone.Index + zone.Length;
+                }
+            }
         }
     }
 }
diff --git a/lang/csharp/src/apache/codegen/Generator.cs b/lang/csharp/src/apache/codegen/Generator.cs
new file mode 100644
index 00000000000..81234939b49
--- /dev/null
+++ b/lang/csharp/src/apache/codegen/Generator.cs
@@ -0,0 +1,153 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System;
+using System.Collections.Generic;
+
+namespace Avro
+{
+    public static class Generator
+    {
+        /// <summary>
+        /// Generates the protocol.
+        /// </summary>
+        /// <param name="protocolArguments">The protocol arguments.</param>
+        public static void GenerateProtocol(ProtocolArguments protocolArguments)
+        {
+            ValidateArguments(protocolArguments);
+            string text = GetFileContent(protocolArguments.ProtocolFile);
+            Protocol protocol = Protocol.Parse(text);
+            CodeGen codeGen = new CodeGen();
+            codeGen.AddProtocol(protocol);
+            AddNamespaceMapping(protocolArguments.NamespaceMapping, ref codeGen);
+            codeGen.GenerateCode();
+            codeGen.WriteTypes(protocolArguments.OutputDirectory);
+        }
+
+        /// <summary>
+        /// Generates the schema.
+        /// </summary>
+        /// <param name="schemaArguments">The schema arguments.</param>
+        public static void GenerateSchema(SchemaArguments schemaArguments)
+        {
+            ValidateArguments(schemaArguments);
+            string text = GetFileContent(schemaArguments.SchemaFile);
+            Schema schema = Schema.Parse(text);
+            CodeGen codeGen = new CodeGen();
+            codeGen.AddSchema(schema);
+            AddNamespaceMapping(schemaArguments.NamespaceMapping, ref codeGen);
+            codeGen.GenerateCode();
+            codeGen.WriteTypes(schemaArguments.OutputDirectory, schemaArguments.CreateNamespaceDirectories);
+        }
+
+        /// <summary>
+        /// Adds the namespace mapping.
+        /// </summary>
+        /// <param name="namespaces">The namespaces.</param>
+        /// <param name="codeGen">The code gen instance.</param>
+        /// <exception cref="ArgumentNullException">codeGen</exception>
+        private static void AddNamespaceMapping(Dictionary<string, string> namespaces, ref CodeGen codeGen)
+        {
+            if (codeGen == null)
+            {
+                throw new ArgumentNullException(nameof(codeGen));
+            }
+
+            foreach (KeyValuePair<string, string> entry in namespaces)
+            {
+                codeGen.NamespaceMapping[entry.Key] = entry.Value;
+            }
+        }
+
+        /// <summary>
+        /// Gets the content of the file.
+        /// </summary>
+        /// <param name="filePath">The file path.</param>
+        /// <returns></returns>
+        /// <exception cref="Avro.AvroException">Content is empty for {filePath}</exception>
+        private static string GetFileContent(string filePath)
+        {
+            string text = System.IO.File.ReadAllText(filePath);
+
+            if (string.IsNullOrWhiteSpace(text))
+            {
+                throw new AvroException($"Content is empty for {filePath}");
+            }
+
+            return text;
+        }
+
+        /// <summary>
+        /// Validates the arguments.
+        /// </summary>
+        /// <param name="schemaArguments">The schema arguments.</param>
+        /// <exception cref="ArgumentNullException">schemaArguments</exception>
+        private static void ValidateArguments(SchemaArguments schemaArguments)
+        {
+            if (schemaArguments == null)
+            {
+                throw new ArgumentNullException(nameof(schemaArguments));
+            }
+
+            ValidateFilePath(schemaArguments.SchemaFile);
+            ValidateDirectory(schemaArguments.OutputDirectory);
+        }
+
+        /// <summary>
+        /// Validates the arguments.
+        /// </summary>
+        /// <param name="protocolArguments">The protocol arguments.</param>
+        /// <exception cref="ArgumentNullException">protocolArguments</exception>
+        private static void ValidateArguments(ProtocolArguments protocolArguments)
+        {
+            if (protocolArguments == null)
+            {
+                throw new ArgumentNullException(nameof(protocolArguments));
+            }
+
+            ValidateFilePath(protocolArguments.ProtocolFile);
+            ValidateDirectory(protocolArguments.OutputDirectory);
+        }
+
+        /// <summary>
+        /// Validates the directory.
+        /// </summary>
+        /// <param name="directory">The directory.</param>
+        /// <exception cref="System.IO.DirectoryNotFoundException">Directory can not be found {directory}</exception>
+        private static void ValidateDirectory(string directory)
+        {
+            if (!System.IO.Directory.Exists(directory))
+            {
+                throw new System.IO.DirectoryNotFoundException($"Directory can not be found {directory}");
+            }
+        }
+
+        /// <summary>
+        /// Validates the file path.
+        /// </summary>
+        /// <param name="filePath">The file path.</param>
+        /// <exception cref="System.IO.FileNotFoundException">Path to input was not found {filePath}</exception>
+        private static void ValidateFilePath(string filePath)
+        {
+            if (!System.IO.File.Exists(filePath))
+            {
+                throw new System.IO.FileNotFoundException($"Path to input was not found {filePath}");
+            }
+        }
+    }
+}
diff --git a/lang/csharp/src/apache/codegen/Models/Arguments.cs b/lang/csharp/src/apache/codegen/Models/Arguments.cs
new file mode 100644
index 00000000000..318e2e9fcf3
--- /dev/null
+++ b/lang/csharp/src/apache/codegen/Models/Arguments.cs
@@ -0,0 +1,65 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System.Collections.Generic;
+
+namespace Avro
+{
+    public abstract class Arguments
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Arguments"/> class.
+        /// </summary>
+        public Arguments()
+        {
+            NamespaceMapping = new Dictionary<string, string>();
+        }
+
+        /// <summary>
+        /// Gets or sets the namespace mapping.
+        /// </summary>
+        /// <value>
+        /// The namespace mapping.
+        /// </value>
+        public Dictionary<string, string> NamespaceMapping { get; set; }
+
+        /// <summary>
+        /// Gets or sets the output directory.
+        /// </summary>
+        /// <value>
+        /// The output directory.
+        /// </value>
+        public string OutputDirectory { get; set; }
+
+        /// <summary>
+        /// Gets a value indicating whether this instance has namespace mapping.
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> if this instance has namespace mapping; otherwise, <c>false</c>.
+        /// </value>
+        internal bool HasNamespaceMapping => NamespaceMapping.Count > 0;
+
+        /// <summary>
+        /// Gets a value indicating whether this instance has output directory.
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> if this instance has output directory; otherwise, <c>false</c>.
+        /// </value>
+        internal bool HasOutputDirectory => !string.IsNullOrEmpty(OutputDirectory);
+    }
+}
diff --git a/lang/csharp/src/apache/codegen/Models/CommandLineArgument.cs b/lang/csharp/src/apache/codegen/Models/CommandLineArgument.cs
new file mode 100644
index 00000000000..9e553c43c29
--- /dev/null
+++ b/lang/csharp/src/apache/codegen/Models/CommandLineArgument.cs
@@ -0,0 +1,73 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System.Collections.Generic;
+
+namespace Avro
+{
+    internal class CommandLineArgument
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CommandLineArgument"/> class.
+        /// </summary>
+        public CommandLineArgument()
+        {
+            Aliases = new List<string>();
+        }
+
+        /// <summary>
+        /// Gets or sets the aliases, which are variations allowed instead of the parameter.
+        /// </summary>
+        /// <value>
+        /// The aliases.
+        /// </value>
+        public List<string> Aliases { get; set; }
+
+        /// <summary>
+        /// Gets or sets the Friendly Name.
+        /// </summary>
+        /// <value>
+        /// The Friendly Name.
+        /// </value>
+        public string FriendlyName { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether this parameter is optional.
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> if this parameter is optional; otherwise, <c>false</c>.
+        /// </value>
+        public bool IsOptional { get; set; }
+
+        /// <summary>
+        /// Gets or sets the parameter.
+        /// </summary>
+        /// <value>
+        /// The parameter.
+        /// </value>
+        public string Parameter { get; set; }
+
+        /// <summary>
+        /// Gets or sets the usage text.
+        /// </summary>
+        /// <value>
+        /// The usage text.
+        /// </value>
+        public string Usage { get; set; }
+    }
+}
diff --git a/lang/csharp/src/apache/codegen/Models/ProtocolArguments.cs b/lang/csharp/src/apache/codegen/Models/ProtocolArguments.cs
new file mode 100644
index 00000000000..5b26b6ba221
--- /dev/null
+++ b/lang/csharp/src/apache/codegen/Models/ProtocolArguments.cs
@@ -0,0 +1,46 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Avro
+{
+    public class ProtocolArguments : Arguments
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ProtocolArguments"/> class.
+        /// </summary>
+        public ProtocolArguments() : base()
+        {
+        }
+
+        /// <summary>
+        /// Gets or sets the protocol file.
+        /// </summary>
+        /// <value>
+        /// The protocol file.
+        /// </value>
+        public string ProtocolFile { get; set; }
+
+        /// <summary>
+        /// Gets a value indicating whether this instance has protocol file.
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> if this instance has protocol file; otherwise, <c>false</c>.
+        /// </value>
+        internal bool HasProtocolFile => !string.IsNullOrEmpty(ProtocolFile);
+    }
+}
diff --git a/lang/csharp/src/apache/codegen/Models/SchemaArguments.cs b/lang/csharp/src/apache/codegen/Models/SchemaArguments.cs
new file mode 100644
index 00000000000..15bd3a8abb1
--- /dev/null
+++ b/lang/csharp/src/apache/codegen/Models/SchemaArguments.cs
@@ -0,0 +1,55 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Avro
+{
+    public class SchemaArguments : Arguments
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SchemaArguments"/> class.
+        /// </summary>
+        public SchemaArguments() : base()
+        {
+            CreateNamespaceDirectories = true;
+        }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether [create namespace directories].
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> if [create namespace directories]; otherwise, <c>false</c>.
+        /// </value>
+        public bool CreateNamespaceDirectories { get; set; }
+
+        /// <summary>
+        /// Gets or sets the schema file.
+        /// </summary>
+        /// <value>
+        /// The schema file.
+        /// </value>
+        public string SchemaFile { get; set; }
+
+        /// <summary>
+        /// Gets a value indicating whether this instance has schema file.
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> if this instance has schema file; otherwise, <c>false</c>.
+        /// </value>
+        internal bool HasSchemaFile => !string.IsNullOrEmpty(SchemaFile);
+    }
+}
diff --git a/lang/csharp/src/apache/main/CodeGen/CodeGen.cs b/lang/csharp/src/apache/main/CodeGen/CodeGen.cs
index 922bfe02fda..d88c60c6116 100644
--- a/lang/csharp/src/apache/main/CodeGen/CodeGen.cs
+++ b/lang/csharp/src/apache/main/CodeGen/CodeGen.cs
@@ -1110,7 +1110,8 @@ public virtual void WriteCompileUnit(string outputFile)
         /// Writes each types in each namespaces into individual files.
         /// </summary>
         /// <param name="outputdir">name of directory to write to.</param>
-        public virtual void WriteTypes(string outputdir)
+        /// <param name="createNamespaceDirectories">if set to <c>true</c> [create namespace directories].</param>
+        public virtual void WriteTypes(string outputdir, bool createNamespaceDirectories = true)
         {
             var cscp = new CSharpCodeProvider();
 
@@ -1125,9 +1126,12 @@ public virtual void WriteTypes(string outputdir)
                 var ns = nsc[i];
 
                 string dir = outputdir;
-                foreach (string name in CodeGenUtil.Instance.UnMangle(ns.Name).Split('.'))
+                if (createNamespaceDirectories)
                 {
-                    dir = Path.Combine(dir, name);
+                    foreach (string name in CodeGenUtil.Instance.UnMangle(ns.Name).Split('.'))
+                    {
+                        dir = Path.Combine(dir, name);
+                    }
                 }
 
                 Directory.CreateDirectory(dir);