C#: Adatok kimentése adatbázisból változóba vagy tömbbe

A C# egy erőteljes programozási nyelv, amelyet gyakran használnak adatbázis-kezelő alkalmazások fejlesztésére. Az adatbázisból származó adatok kinyerése és azokkal való munka az alkalmazások egyik alapvető funkciója. Ebben a cikkben bemutatjuk, hogyan lehet adatokat kinyerni egy adatbázisból, és azokat változókban vagy tömbökben tárolni, a jobb kezelhetőség és feldolgozhatóság érdekében.

Bevezetés az Adatbázis-kezelésbe C#-ban

A .NET Framework és a .NET Core számos lehetőséget kínál az adatbázisokhoz való kapcsolódásra. A leggyakoribb megközelítések közé tartozik az ADO.NET használata, valamint az Entity Framework Core (EF Core), egy ORM (Object-Relational Mapper) eszköz, amely leegyszerűsíti az adatbázis-műveleteket.

ADO.NET Használata

Az ADO.NET egy alacsonyabb szintű megközelítés, amely közvetlen hozzáférést biztosít az adatbázishoz. Nézzük meg, hogyan tudunk adatokat kinyerni egy adatbázisból és változókba, illetve tömbökbe menteni:

1. Csatlakozás az Adatbázishoz

Először létre kell hoznunk egy kapcsolatot az adatbázishoz. A kapcsolati string az adatbázis típusától és a kapcsolódási beállításoktól függően változik. Például egy SQL Server adatbázishoz a következőképpen nézhet ki:

string connectionString = "Data Source=SERVER_NAME;Initial Catalog=DATABASE_NAME;Integrated Security=True;";

Fontos, hogy a SERVER_NAME és DATABASE_NAME helyére a megfelelő értékeket írjuk.

2. Lekérdezés Létrehozása

Következő lépés a lekérdezés (SQL query) létrehozása, amely meghatározza, hogy mely adatokat szeretnénk kinyerni.

string query = "SELECT ID, Name, Email FROM Users";

3. Az Adatok Kinyerése és Változókba Mentése

Most már végrehajthatjuk a lekérdezést, és az eredményül kapott adatokat változókba menthetjük. Ehhez a következő lépéseket kell követni:

using (SqlConnection connection = new SqlConnection(connectionString))
{
    connection.Open();

    using (SqlCommand command = new SqlCommand(query, connection))
    {
        using (SqlDataReader reader = command.ExecuteReader())
        {
            while (reader.Read())
            {
                int id = reader.GetInt32(0);
                string name = reader.GetString(1);
                string email = reader.GetString(2);

                Console.WriteLine($"ID: {id}, Name: {name}, Email: {email}");
            }
        }
    }
}

Ebben a példában minden sor adatait egy-egy változóba mentjük. A reader.GetInt32(0), reader.GetString(1) stb. metódusok a sorban lévő megfelelő indexű oszlop értékét olvassák ki. Fontos a megfelelő adattípust használni a reader metódusoknál (pl. GetInt32 az integerhez, GetString a stringhez).

4. Az Adatok Kinyerése és Tömbbe Mentése

Ha az adatokat tömbben szeretnénk tárolni, akkor a következőképpen tehetjük meg:

List<int> ids = new List<int>();
List<string> names = new List<string>();
List<string> emails = new List<string>();

using (SqlConnection connection = new SqlConnection(connectionString))
{
    connection.Open();

    using (SqlCommand command = new SqlCommand(query, connection))
    {
        using (SqlDataReader reader = command.ExecuteReader())
        {
            while (reader.Read())
            {
                ids.Add(reader.GetInt32(0));
                names.Add(reader.GetString(1));
                emails.Add(reader.GetString(2));
            }
        }
    }
}

// Példa a tömbök használatára
for (int i = 0; i < ids.Count; i++)
{
    Console.WriteLine($"ID: {ids[i]}, Name: {names[i]}, Email: {emails[i]}");
}

Ebben a példában három listát hozunk létre, egyet az ID-knak, egyet a neveknek, és egyet az e-mail címeknek. A while ciklusban minden sor adatait hozzáadjuk a megfelelő listához. A List osztály dinamikus méretű tömböt valósít meg, így nem kell előre megadnunk a tömb méretét.

Entity Framework Core (EF Core) Használata

Az Entity Framework Core egy magasabb szintű megközelítés, amely leegyszerűsíti az adatbázis-kezelést. Az EF Core automatikusan leképezi az adatbázis tábláit C# osztályokká (entitásokká), így az adatbázis-műveleteket objektumorientált módon végezhetjük el.

1. A Kontextus Létrehozása

Először létre kell hoznunk egy kontextust, amely képviseli az adatbázist.

public class BloggingContext : DbContext
{
    public BloggingContext(DbContextOptions<BloggingContext> options) : base(options) { }

    public DbSet<Blog> Blogs { get; set; }
    public DbSet<Post> Posts { get; set; }
}

2. Az Adatok Kinyerése

Az adatok kinyerése az EF Core-ban nagyon egyszerű:

using (var context = new BloggingContext())
{
    var blogs = context.Blogs.ToList();

    foreach (var blog in blogs)
    {
        Console.WriteLine($"Blog ID: {blog.BlogId}, Blog URL: {blog.Url}");
    }
}

Ez a kód lekéri az összes blogot a Blogs táblából, és kiírja azok ID-ját és URL-jét. A ToList() metódus az adatokat egy listába rendezi.

3. Adatok Mentése Változókba és Tömbökbe (EF Core)

Az adatokat hasonlóan, mint az ADO.NET esetén, változókba vagy tömbökbe menthetjük. Például:

using (var context = new BloggingContext())
{
    List<int> blogIds = new List<int>();
    List<string> blogUrls = new List<string>();

    foreach (var blog in context.Blogs)
    {
        blogIds.Add(blog.BlogId);
        blogUrls.Add(blog.Url);
    }

    // Példa a tömbök használatára
    for (int i = 0; i < blogIds.Count; i++)
    {
        Console.WriteLine($"Blog ID: {blogIds[i]}, Blog URL: {blogUrls[i]}");
    }
}

Összegzés

Ebben a cikkben bemutattuk, hogyan lehet adatokat kinyerni egy adatbázisból C# nyelven, mind az ADO.NET, mind az Entity Framework Core használatával. Megtanultuk, hogyan lehet az adatokat változókba és tömbökbe menteni, ami elengedhetetlen az adatok további feldolgozásához és megjelenítéséhez. A megfelelő megközelítés kiválasztása a projekt igényeitől és komplexitásától függ. Az ADO.NET nagyobb kontrollt biztosít, míg az EF Core leegyszerűsíti a fejlesztést és csökkenti a kód mennyiségét. Mindkét technológia elengedhetetlen a C# fejlesztők eszköztárában.