Since the launch of #DeepSeek, I have been evaluating different use cases across various domains and technology stacks. However, as of writing this post, I must say I am disappointed with its chat portal—though I am amazed by the R1 capabilities described in the paper.
Now, coming to a sample comparison with #ChatGPT GPT-4o—I am still impressed with OpenAI’s efficiency. My query was:
“Write a C# program in the most complex way possible to find the sum of two numbers.”
DeepSeek Chat, as has been the case recently, showed busy servers,
and after several attempts, I finally received a response in a slow, think-and-type manner. I understand this is a new system, so improvements will take time. However, it went a bit too far, generating a detailed program with additional explanations beyond what I asked for.
For the above question, DeepSeek used: Interfaces & Generics, Reflection, Delegates, LINQ, Async programming, and some error handling.
Yes, this is impressive.
using System;
using System.Linq;
using System.Reflection;
using System.Threading.Tasks;
namespace OverEngineeredSum
{
public interface IMathOperation<T>
{
Task<T> ExecuteAsync(T a, T b);
}
public class SumOperation : IMathOperation<int>
{
public async Task<int> ExecuteAsync(int a, int b)
{
// Simulate some async work
await Task.Delay(100);
// Use LINQ for no reason
var numbers = new[] { a, b };
return numbers.Aggregate((x, y) => x + y);
}
}
public class MathOperationFactory
{
public static IMathOperation<T> CreateOperation<T>()
{
// Use reflection to find the correct operation
var operationType = Assembly.GetExecutingAssembly()
.GetTypes()
.FirstOrDefault(t => t.GetInterfaces()
.Any(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IMathOperation<>)));
if (operationType == null)
throw new InvalidOperationException("No math operation found.");
return (IMathOperation<T>)Activator.CreateInstance(operationType);
}
}
public delegate Task<int> SumDelegate(int a, int b);
public static class Program
{
public static async Task Main(string[] args)
{
// Use a delegate for no reason
SumDelegate sumDelegate = async (a, b) =>
{
var operation = MathOperationFactory.CreateOperation<int>();
return await operation.ExecuteAsync(a, b);
};
// Use a complex way to parse input
int num1 = int.Parse(Console.ReadLine() ?? throw new InvalidOperationException("Input cannot be null."));
int num2 = int.Parse(Console.ReadLine() ?? throw new InvalidOperationException("Input cannot be null."));
// Use async/await for no reason
int result = await sumDelegate(num1, num2);
Console.WriteLine($"The sum of {num1} and {num2} is: {result}");
}
}
}But, ChatGPT went one step further:
It not only provided a more complex code than DeepSeek but also explained the complex, efficiently educating me the strategy. I liked the way they used design patterns.
using System;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Threading;
using System.Threading.Tasks;
// Define an interface for operations
public interface IOperation
{
int Execute();
}
// Abstract class providing base functionality
public abstract class OperationBase : IOperation
{
protected int _a, _b;
public OperationBase(int a, int b) { _a = a; _b = b; }
public abstract int Execute();
}
// Concrete class for sum operation
public class SumOperation : OperationBase
{
public SumOperation(int a, int b) : base(a, b) { }
public override int Execute()
{
return _a + _b;
}
}
// Factory for creating operations
public static class OperationFactory
{
public static IOperation CreateOperation(string type, int a, int b)
{
if (type == "sum")
return new SumOperation(a, b);
throw new InvalidOperationException("Unknown operation type");
}
}
// Delegate to notify completion
public delegate void SumCompletedHandler(int result);
// Calculator using events and delegates
public class ComplexCalculator
{
public event SumCompletedHandler SumCompleted;
public void ComputeSumAsync(int a, int b)
{
Task.Run(() =>
{
var operation = OperationFactory.CreateOperation("sum", a, b);
int result = operation.Execute();
// Invoke event
SumCompleted?.Invoke(result);
});
}
}
// Reflection-based executor
public static class ReflectionExecutor
{
public static int InvokeSumOperation(int a, int b)
{
Type type = typeof(SumOperation);
ConstructorInfo ctor = type.GetConstructor(new Type[] { typeof(int), typeof(int) });
object instance = ctor.Invoke(new object[] { a, b });
MethodInfo executeMethod = type.GetMethod("Execute");
return (int)executeMethod.Invoke(instance, null);
}
}
// Expression tree to generate sum dynamically
public static class DynamicSumGenerator
{
public static Func<int, int, int> GenerateSumFunction()
{
ParameterExpression paramA = Expression.Parameter(typeof(int), "a");
ParameterExpression paramB = Expression.Parameter(typeof(int), "b");
BinaryExpression sumExpression = Expression.Add(paramA, paramB);
return Expression.Lambda<Func<int, int, int>>(sumExpression, paramA, paramB).Compile();
}
}
// Entry Point
class Program
{
static void Main()
{
int a = 5, b = 7;
// 1. Factory-based operation execution
IOperation operation = OperationFactory.CreateOperation("sum", a, b);
Console.WriteLine("Factory Method Sum: " + operation.Execute());
// 2. Using reflection to invoke the sum
Console.WriteLine("Reflection-based Sum: " + ReflectionExecutor.InvokeSumOperation(a, b));
// 3. Using expression tree
var sumFunc = DynamicSumGenerator.GenerateSumFunction();
Console.WriteLine("Expression Tree Sum: " + sumFunc(a, b));
// 4. Multi-threaded computation using event
ComplexCalculator calculator = new ComplexCalculator();
calculator.SumCompleted += (result) => Console.WriteLine("Async Sum Completed: " + result);
calculator.ComputeSumAsync(a, b);
// Keep main thread alive to see async result
Thread.Sleep(1000);
}
}
Breakdown of Complexity:
✅ Factory Pattern: Creates a sum operation dynamically.
✅ Abstract Classes & Interfaces: Adds unnecessary layers of abstraction.
✅ Reflection: Creates an instance of SumOperation and invokes Execute method dynamically.
✅ Expression Trees: Generates the addition function at runtime.
✅ Multi-threading: Runs sum computation asynchronously using Task.
✅ Event Handling: Notifies sum completion via a delegate.
✅ Manual Dependency Injection: Factory handles object creation.
Here is the ChatGPT script – https://chatgpt.com/share/6799e106-bd84-8000-8753-e68a7430fbfe. Unfortunately DeepSeek yet to give a direct chat link feature.