Przewodnik: Wykonywanie zapytań w relacjach (C#)

W tym przewodniku przedstawiono użycie skojarzeń LINQ to SQL do reprezentowania relacji klucza obcego w bazie danych.

Uwaga

Na komputerze w poniższych instrukcjach mogą być wyświetlane inne nazwy i lokalizacje niektórych elementów interfejsu użytkownika programu Visual Studio. Te elementy są określane przez numer wersji Visual Studio oraz twoje ustawienia. Aby uzyskać więcej informacji, zobacz Personalizowanie środowiska IDE.

Ten przewodnik został napisany przy użyciu programu Visual C# Development Ustawienia.

Wymagania wstępne

Musisz ukończyć przewodnik: prosty model obiektów i zapytanie (C#). Ten przewodnik opiera się na tym, w tym obecności pliku northwnd.mdf w c:\linqtest5.

Omówienie

Ten przewodnik składa się z trzech głównych zadań:

• Dodanie klasy jednostki do reprezentowania tabeli Orders (Zamówienia) w przykładowej bazie danych Northwind.

• Uzupełnienie adnotacji do Customer klasy w celu zwiększenia relacji między klasami Customer i Order .

• Tworzenie i uruchamianie zapytania w celu przetestowania uzyskiwania OrderCustomer informacji przy użyciu klasy .

Mapowanie relacji między tabelami

Customer Po definicji klasy utwórz definicję Order klasy jednostki, która zawiera następujący kod, który wskazuje, że Order.Customer odnosi się jako klucz obcy do Customer.CustomerID.

Aby dodać klasę jednostki Order

• Wpisz lub wklej następujący kod po Customer klasie:

  [Table(Name = "Orders")]
  public class Order
  {
      private int _OrderID = 0;
      private string _CustomerID;
      private EntityRef<Customer> _Customer;
      public Order() { this._Customer = new EntityRef<Customer>(); }
  
      [Column(Storage = "_OrderID", DbType = "Int NOT NULL IDENTITY",
      IsPrimaryKey = true, IsDbGenerated = true)]
      public int OrderID
      {
          get { return this._OrderID; }
          // No need to specify a setter because IsDBGenerated is
          // true.
      }
  
      [Column(Storage = "_CustomerID", DbType = "NChar(5)")]
      public string CustomerID
      {
          get { return this._CustomerID; }
          set { this._CustomerID = value; }
      }
  
      [Association(Storage = "_Customer", ThisKey = "CustomerID")]
      public Customer Customer
      {
          get { return this._Customer.Entity; }
          set { this._Customer.Entity = value; }
      }
  }
  

Dodawanie adnotacji do klasy klienta

W tym kroku dodasz adnotację Customer do klasy, aby wskazać jej relację z klasą Order . (Ten dodatek nie jest ściśle konieczny, ponieważ zdefiniowanie relacji w obu kierunkach jest wystarczające do utworzenia łącza. Jednak dodanie tej adnotacji umożliwia łatwe nawigowanie po obiektach w obu kierunkach).

Aby dodać adnotację do klasy Customer

• Wpisz lub wklej następujący kod do Customer klasy:

  private EntitySet<Order> _Orders;
  public Customer()
  {
      this._Orders = new EntitySet<Order>();
  }
  
  [Association(Storage = "_Orders", OtherKey = "CustomerID")]
  public EntitySet<Order> Orders
  {
      get { return this._Orders; }
      set { this._Orders.Assign(value); }
  }
  

Tworzenie i uruchamianie zapytania w relacji zamówienie klienta

Teraz można uzyskiwać dostęp do Order obiektów bezpośrednio z Customer obiektów lub w odwrotnej kolejności. Nie potrzebujesz jawnego sprzężenia między klientami i zamówieniami.

Aby uzyskać dostęp do obiektów Order przy użyciu obiektów klienta

1. Zmodyfikuj metodę Main , wpisując lub wklejając następujący kod w metodzie :

   // Query for customers who have placed orders.
   var custQuery =
       from cust in Customers
       where cust.Orders.Any()
       select cust;
   
   foreach (var custObj in custQuery)
   {
       Console.WriteLine("ID={0}, Qty={1}", custObj.CustomerID,
           custObj.Orders.Count);
   }
   

2. Naciśnij klawisz F5, aby debugować aplikację.

   Uwaga

   Kod SQL można wyeliminować w oknie Konsola, komentując db.Log = Console.Out;element .

3. Naciśnij klawisz Enter w oknie Konsola, aby zatrzymać debugowanie.

Tworzenie silnie typizowanego widoku bazy danych

Znacznie łatwiej jest rozpocząć od silnie typizowanego widoku bazy danych. W przypadku silnego DataContext wpisywania obiektu nie trzeba wywołać metody GetTable. W przypadku używania silnie typizowanego obiektu można użyć silnie typiowanych DataContext tabel we wszystkich zapytaniach.

W poniższych krokach utworzysz Customers silnie typizowana tabelę, która jest mapowana na tabelę Customers w bazie danych.

Aby silnie wpisać obiekt DataContext

1. Dodaj następujący kod powyżej deklaracji Customer klasy.

   public class Northwind : DataContext
   {
       // Table<T> abstracts database details per table/data type.
       public Table<Customer> Customers;
       public Table<Order> Orders;
   
       public Northwind(string connection) : base(connection) { }
   }
   

2. Zmodyfikuj metodę , Main aby używać silnie typizowanej DataContext metody w następujący sposób:

   // Use a connection string.
   Northwind db = new Northwind(@"C:\linqtest5\northwnd.mdf");
   
   // Query for customers from Seattle.
   var custQuery =
       from cust in db.Customers
       where cust.City == "Seattle"
       select cust;
   
   foreach (var custObj in custQuery)
   {
       Console.WriteLine("ID={0}", custObj.CustomerID);
   }
   // Freeze the console window.
   Console.ReadLine();
   

3. Naciśnij klawisz F5, aby debugować aplikację.

   Dane wyjściowe okna konsoli to:

   ID=WHITC

4. Naciśnij klawisz Enter w oknie konsoli, aby zatrzymać debugowanie.

Następne kroki

W następnym przewodniku (Przewodnik: manipulowanie danymi (C#)) pokazano, jak manipulować danymi. Ten przewodnik nie wymaga zapisania dwóch przewodników w tej serii, które zostały już ukończone.

Zobacz też

• Nauka przez przewodniki