Using ChatGPT for C# Development

ChatGPT is transforming how developers write and improve code. This article explores how you can use ChatGPT to accelerate C# development, improve code quality, and boost productivity.

What is ChatGPT?

ChatGPT (short for Chat Generative Pre-trained Transformer) is a natural language processing (NLP) model developed by OpenAI . It generates human-like responses to text input and has been trained on a large dataset to learn the patterns and nuances of language.

The model can answer questions, assist with tasks like composing emails, essays, and code. It is currently open to the public for research and feedback collection.

While some technology behind ChatGPT is open source, the specific model and its parameters are proprietary. ChatGPT is only available as a cloud-based service.

ChatGPT learns through training on large datasets, enabling it to generate responses to new text input.

For more information, see the OpenAI Blog or watch the video below.

ChatGPT for C# Developers

ChatGPT can be used to answer technical questions, provide information about the development process, and improve productivity. It is a valuable tool alongside GitHub Copilot and Stack Overflow.

Not every response from ChatGPT is correct or runnable, but it provides another tool for developers to improve their workflow.

Real-World Examples

Explaining Existing Code Blocks

ChatGPT can explain code you don't fully understand. This is especially useful for legacy or complex code.

// Input:
// Can you explain this C# code to me?
public class MyClass
{
  public int Property { get; set; }
}
// Output:
// This code defines a class called "MyClass" with a single property called "Property".
// The property is of type "int" and is publicly accessible using the "get" and "set" accessors.

Improving Existing Code

ChatGPT can help you improve code by suggesting modifications and refactoring for clarity and maintainability.

    Can you help me refactor this code to make it more readable?
    // This code defines a function that sorts an array of integers
    public void QuickSort(int[] array)
    {
        if (array.Length <= 1) return;
        int pivot = array[array.Length / 2];
        int left = 0;
        int right = array.Length - 1;
        while (left <= right)
        {
            while (array[left] < pivot) left++;
            while (array[right] > pivot
        }
    }

This is what Chat GPT returns:

    public void QuickSort(int[] array)
        {
            if (array.Length <= 1)
            {
                return;
            }

            int pivot = array[array.Length / 2];
            int left = 0;
            int right = array.Length - 1;

            while (left <= right)
            {
                while (array[left] < pivot)
                {
                    left++;
                }

                while (array[right] > pivot)
                {
                    right--;
                }

                if (left <= right)
                {
                    int temp = array[left];
                    array[left] = array[right];
                    array[right] = temp;
                    left++;
                    right--;
                }
            }

            QuickSort(array.Take(right + 1).ToArray());
            QuickSort(array.Skip(left).ToArray());
        }
        

The refactored version includes clearer variable names, explicit code blocks, and improved readability.

Rewriting Code for Style

ChatGPT can help rewrite code to follow C# conventions and best practices.

// Input:
// Can you help me rewrite this code to follow C# naming conventions?
public class MyClass
{
  public int Prop { get; set; }
  public void Do_Something()
  {
    // Method body
  }
}
// Output:
public class MyClass
{
  public int Prop { get; set; }
  public void DoSomething()
  {
    // Method body
  }
}

ChatGPT renames properties and methods to follow C# naming conventions, improving code style and maintainability.

Rewriting Code with Idiomatic Constructs

ChatGPT can refactor code to use idiomatic C# constructs, making it more readable and efficient.

// Input:
// Can you help me rewrite this code to use C# idiomatic constructs?
public int SumArray(int[] array)
{
  int sum = 0;
  for (int i = 0; i < array.Length; i++)
  {
    sum += array[i];
  }
  return sum;
}
// Output:
public int SumArray(int[] array)
{
  int sum = 0;
  foreach (int element in array)
  {
    sum += element;
  }
  return sum;
}

Using idiomatic constructs makes code more concise and easier to understand.

Simplifying Existing Code

ChatGPT can suggest alternative implementations that are more efficient or easier to understand.

    Rewrite the following C# method to be more efficient:

        public double Average(List<int> numbers)
        {
            double sum = 0;
            foreach (int number in numbers)
            {
                sum += number;
            }
            return sum / numbers.Count;
        }
        

ChatGPT might suggest the following alternative implementation, which uses the Sum() method of the List of int class to more efficiently calculate the sum of the numbers:

    public double Average(List<int> numbers)
        {
            if (numbers.Count == 0)
            {
                return 0;
            }
            return numbers.Sum() / (double) numbers.Count;
        }
        

Writing Test Cases

ChatGPT can generate test cases for your C# code, saving time and improving coverage.

    Write test cases for the following C# method that cover edge cases:

        public int Factorial(int n)
        {
            if (n < 0)
            {
                throw new ArgumentException("n must be non-negative");
            }
            if (n == 0)
            {
                return 1;
            }
            return n * Factorial(n - 1);
        }
        

This is what Chat GPT returns:

[Test]
public void TestFactorialEdgeCases()
{
    Assert.Throws<ArgumentException>(() => Factorial(-1));
    Assert.AreEqual(1, Factorial(0));
    Assert.AreEqual(1, Factorial(1));
    Assert.AreEqual(2, Factorial(2));
    Assert.AreEqual(6, Factorial(3));
    Assert.AreEqual(40320, Factorial(8));
}

Writing Documentation

ChatGPT can generate documentation for your code using XML comments and summaries.

    Write documentation for the following C# method:

        public double Average(List<int> numbers)
        {
            if (numbers.Count == 0)
            {
                return 0;
            }
            return numbers.Sum() / (double) numbers.Count;
        }

        The method calculates the average of the integers in the input list. If the list is empty, it returns 0.
        

This is what Chat GPT returns:

    /// <summary>
        /// Calculates the average of the integers in the input list.
        /// If the list is empty, it returns 0.
        /// </summary>
        /// <param name="numbers">The list of integers to calculate the average of.</param>
        /// <returns>The average of the integers in the input list, or 0 if the list is empty.</returns>
        public double Average(List<int> numbers)
        {
            if (numbers.Count == 0)
            {
                return 0;
            }
            return numbers.Sum() / (double) numbers.Count;
        }
        

Scaffolding Code

ChatGPT can scaffold code structures or templates to speed up development.

    public class ApiClient
    {
        private readonly HttpClient _httpClient;

        public ApiClient(string baseUrl)
        {
            _httpClient = new HttpClient
            {
                BaseAddress = new Uri(baseUrl)
            };
        }

        public async Task<T> GetAsync<T>(string url)
        {
            var response = await _httpClient.GetAsync(url);
            response.EnsureSuccessStatusCode();
            return await response.Content.ReadAsAsync<T>();
        }

        public async Task<HttpResponseMessage> PostAsync<T>(string url, T data)
        {
            var content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");
            return await _httpClient.PostAsync(url, content);
        }
    }
    

The generated code is concise and ready for customization and refactoring.

Example: Limiting concurrent REST calls with SemaphoreSlim and Task.WhenAll.

|
|
| public async Task Make1000RestCallsAsync()
| {
| // Create a SemaphoreSlim with a maximum of 10 concurrent requests
| SemaphoreSlim semaphore = new SemaphoreSlim(10);
|
| // Create a list of tasks to make the 1000 REST calls
| List
task  tasks = new List
  task
    | ();
    | for (int i = 0; i < 1000; i++)
    | {
    | // Acquire the semaphore before making the request
    | await semaphore.WaitAsync();
    |
    | // Create a task to make the request
    | tasks.Add(Task.Run(async () =>
    | {
    | try
    | {
    | // Make the REST call
    | await MakeRestCallAsync();
    | }
    | finally
    | {
    | // Release the semaphore
    | semaphore.Release();
    | }
    | }));
    | }
    |
    | // Wait for all tasks to complete
    | await Task.WhenAll(tasks);
    |
    | // Log a message when all calls are complete
    | Console.WriteLine("All calls complete");
    | }

Conclusion

ChatGPT is a valuable partner for developers, enabling faster prototyping, better code, and continuous learning. As AI tools evolve, their role in software development will only grow.

For more on AI-assisted development, see: Trivia Spark: Igniting Creativity With ChatGPT