Added ResponseHandler property and default implementation function

src/kiota.core/CodeDOM/CodeMethod.cs

@@ -8,6 +8,7 @@ public class CodeMethod : CodeTerminal, ICloneable
     {
         public CodeType ReturnType;
         public List<CodeParameter> Parameters = new List<CodeParameter>();
+        public bool IsStatic = false;
 
         public object Clone()
         {

src/kiota.core/CodeDOM/CodeProperty.cs

@@ -8,5 +8,6 @@ public override string Name
         }
         public bool ReadOnly = false;
         public CodeType Type;
+        public string DefaultValue;
     }
 }

src/kiota.core/KiotaBuilder.cs

@@ -221,7 +221,10 @@ private void CreateClass(CodeNamespace codeNamespace, OpenApiUrlSpaceNode node)
                     logger.LogDebug("Creating method {name} of {type}", method.Name, method.ReturnType);
                     codeClass.AddMethod(method);
                 }
+
+                CreateResponseHandler(codeClass);
             }
+
 
             codeNamespace.AddClass(codeClass);
 
@@ -246,12 +249,13 @@ private CodeIndexer CreateIndexer(string childIdentifier, string childType)
             return prop;
         }
 
-        private CodeProperty CreateProperty(string childIdentifier, string childType)
+        private CodeProperty CreateProperty(string childIdentifier, string childType, string defaultValue = null)
         {
             var prop = new CodeProperty()
             {
                 Name = childIdentifier,
-                Type = new CodeType() { Name = childType }
+                Type = new CodeType() { Name = childType }, 
+                DefaultValue = defaultValue
             };
             logger.LogDebug("Creating property {name} of {type}", prop.Name, prop.Type.Name);
             return prop;
@@ -380,5 +384,19 @@ private static string FixPathIdentifier(string identifier)
             }
             return identifier.ToCamelCase();
         }
+
+        private void CreateResponseHandler(CodeClass requestBuilder)
+        {
+            // Default ResponseHandler Implementation
+            var responseHandlerImpl = new CodeMethod() { Name = "DefaultResponseHandler", IsStatic = true };
+            responseHandlerImpl.AddParameter(new CodeParameter() { Name = "response", Type = new CodeType() { Name = "object" } });  // replace native HTTP response object type in language refiner
+            responseHandlerImpl.ReturnType = new CodeType() { Name = "object" };
+            requestBuilder.AddMethod(responseHandlerImpl);
+
+            // Property to allow replacing Response Handler
+            var responseHandlerProperty = CreateProperty("ResponseHandler", "Func<object,object>", "DefaultResponseHandler"); // HttpResponseMessage, model
+            responseHandlerProperty.ReadOnly = false;
+            requestBuilder.AddProperty(responseHandlerProperty);  
+        }
     }
 }

src/kiota.core/Refiners/CSharpRefiner.cs

@@ -1,14 +1,45 @@
-using System.Linq;
+using System.Linq;
+using System.Text.RegularExpressions;
 
 namespace kiota.core {
     public class CSharpRefiner : CommonLanguageRefiner, ILanguageRefiner
     {
+        private Regex responseHandlerType = new Regex("<(.*),object>");
         public override void Refine(CodeNamespace generatedCode)
         {
             generatedCode.AddUsing(new CodeUsing() { Name = "System" });
             generatedCode.AddUsing(new CodeUsing() { Name = "System.Threading.Tasks" });
+            generatedCode.AddUsing(new CodeUsing() { Name = "System.Net.Http" });
             AddAsyncSuffix(generatedCode);
             AddInnerClasses(generatedCode);
+            MakeNativeResponseHandlers(generatedCode);
+        }
+
+        private void MakeNativeResponseHandlers(CodeNamespace generatedCode)
+        {
+            foreach (var codeElement in generatedCode.InnerChildElements)
+            {
+                switch (codeElement)
+                {
+                    case CodeClass c:
+                        var responseHandlerProp = c.InnerChildElements.Where(e => e is CodeProperty && e.Name == "ResponseHandler")
+                                                                        .Cast<CodeProperty>().FirstOrDefault();
+                        if (responseHandlerProp != null)
+                        {
+                            responseHandlerProp.Type.Name = responseHandlerType.Replace(responseHandlerProp.Type.Name, "<HttpResponseMessage,Task<$1>>"); // TODO: We should probably generic types properly 
+                        }
+                        var defaultResponseHandler = c.InnerChildElements.Where(e => e is CodeMethod && e.Name == "DefaultResponseHandler")
+                                                                      .Cast<CodeMethod>().FirstOrDefault();
+                        if (defaultResponseHandler != null)
+                        {
+                            defaultResponseHandler.Parameters.FirstOrDefault().Type.Name = "HttpResponseMessage";
+                        }
+                        break;
+                    case CodeNamespace n:
+                        MakeNativeResponseHandlers(n);
+                        break;
+                }
+            }
         }
         private void AddAsyncSuffix(CodeElement currentElement) {
             if(currentElement is CodeMethod currentMethod)

src/kiota.core/Writers/CSharpWriter.cs

@@ -36,8 +36,17 @@ public override void WriteCodeClassEnd(CodeClass.End code)
 
         public override void WriteProperty(CodeProperty code)
         {
-
-            WriteLine($"public {GetTypeString(code.Type)} {code.Name} {{get;}}");
+            var simpleBody = "get;";
+            if (!code.ReadOnly)
+            {
+                simpleBody = "get;set;";
+            }
+            var defaultValue = "";
+            if (code.DefaultValue != null)
+            {
+                defaultValue = " = " + code.DefaultValue + ";";
+            }
+            WriteLine($"public {GetTypeString(code.Type)} {code.Name} {{{simpleBody}}} {defaultValue}");
         }
 
         public override void WriteIndexer(CodeIndexer code)
@@ -47,7 +56,10 @@ public override void WriteIndexer(CodeIndexer code)
 
         public override void WriteMethod(CodeMethod code)
         {
-            WriteLine($"public Task<{GetTypeString(code.ReturnType)}> {code.Name}({string.Join(',', code.Parameters.Select(p=> GetParameterSignature(p)).ToList())}) {{ return null; }}");
+            var staticModifier = code.IsStatic ? "static " : "";
+            // Task type should be moved into the refiner
+            WriteLine($"public {staticModifier}Task<{GetTypeString(code.ReturnType)}> {code.Name}({string.Join(',', code.Parameters.Select(p=> GetParameterSignature(p)).ToList())}) {{ return null; }}");
+
         }
 
         public override void WriteType(CodeType code)