📘 C# Blog Series – Blog 37 **“C# Generics — एक ही Class से Multiple Data Types कैसे Handle करते हैं?

📘 C# Blog Series – Blog 37

**“C# Generics — एक ही Class से Multiple Data Types कैसे Handle करते हैं?

(Real-Life Example: Generic Packet Parser, Generic API Response, Generic Storage)”**

C# Generics वो concept है जिससे आप reusable, type-safe, और high-performance code बना सकते हो।

GPS Tracking, Web API, Billing, ERP—
हर बड़े system में Generics की ज़रूरत पड़ती है।

इससे आपका code:

✔ Duplicate नहीं होता
✔ Type-safe रहता है
✔ Fast काम करता है
✔ Clean architecture बनती है
✔ Performance बढ़ती है

आज हम Generics को आसान तरीके + GPS server के real examples के साथ सीखेंगे।

---

🟦 1. Generics क्या है? (Simple Definition)

Generics =
एक ऐसा class, method या structure जो अलग-अलग data types के साथ काम कर सकता है।

Example:

List<int> numbers = new List<int>();
List<string> names = new List<string>();

Same List class → multiple data types।

---

🟢 2. Generic Class Example

class Box<T>
{
    public T Value { get; set; }
}

Use:

var intBox = new Box<int> { Value = 10 };
var strBox = new Box<string> { Value = "GPS" };

---

⭐ 3. Real-Life GPS Example: Generic API Response

Backend APIs में हर response में:

• status

• message

• data (device, list, settings, etc.)

Use generic model:

class ApiResponse<T>
{
    public string Status { get; set; }
    public string Message { get; set; }
    public T Data { get; set; }
}

Use for single device:

var response = new ApiResponse<GPSDevice>
{
    Status = "OK",
    Message = "Success",
    Data = device
};

Use for list:

var response = new ApiResponse<List<GPSDevice>>
{
    Status = "OK",
    Message = "Success",
    Data = devices
};

Same class → different data types → clean architecture।

---

🌟 4. Real GPS Example: Generic Packet Storage System

Generic memory store:

class Store<T>
{
    private T _value;
    public void Save(T val) => _value = val;
    public T Load() => _value;
}

Use:

var imeiStore = new Store<string>();
imeiStore.Save("86112806...");

var batteryStore = new Store<int>();
batteryStore.Save(90);

One class → many uses.

---

🟠 5. Generic Methods

public void Print<T>(T value)
{
    Console.WriteLine(value);
}

Use:

Print(100);
Print("GPS Packet");
Print(25.90);

One method → unlimited types।

---

🔵 6. Real GPS Example: Generic Logger

class Logger
{
    public void Log<T>(T value)
    {
        File.AppendAllText("log.txt", value.ToString() + "\n");
    }
}

Use:

logger.Log("Packet Received");
logger.Log(85); // battery
logger.Log(device); // object

एक method → हर data type log कर सकता है।

---

🟣 7. Generic Repository Pattern (Professional Architecture)

Define:

interface IRepository<T>
{
    void Add(T item);
    T Get(int id);
    List<T> GetAll();
}

GPS Device Repository:

class DeviceRepository : IRepository<GPSDevice>
{
    ...
}

User Repository:

class UserRepository : IRepository<User>
{
    ...
}

Same structure → different data types।

---

🔥 8. GPS Server Example: Generic Packet Parser System

Abstract parser:

interface IParser<T>
{
    T Parse(string packet);
}

G17 Model:

class G17Parser : IParser<G17Packet>
{
    public G17Packet Parse(string packet) { ... }
}

S15 Model:

class S15Parser : IParser<S15Packet>
{
    public S15Packet Parse(string packet) { ... }
}

Cleaner, reusable, scalable parser architecture।

---

🧠 9. Generic Constraints (Important)

You can restrict types:

class DeviceStore<T> where T : GPSDevice
{
    public List<T> Devices { get; set; }
}

अब सिर्फ GPSDevice inherited classes allowed हैं।

---

📌 10. Benefits of Generics (Must Remember)

✔ Zero duplicate code
✔ Type-safe (compile time errors)
✔ No boxing/unboxing → fast performance
✔ Clean architecture
✔ Perfect for API and backend
✔ Perfect for packet handling
✔ Perfect for scalable systems

---

🔚 Conclusion

Generics आपके system को बनाते हैं:

✔ Flexible
✔ Reusable
✔ Professional
✔ High-performance
✔ Easy to scale
✔ Clean structured architecture

GPS server जैसे systems में Generics का use architecture को ultra-clean बना देता है—
from packet parsers → repositories → API responses तक।