LINQ to SQL 문장의 Insert/Update/Delete 동작

삽입/업데이트/삭제 작업
삽입(삽입)
1.단순 형식
설명:new 대상 은 InsertOnSubmit 방법 으로 해당 하 는 집합 에 추가 하고 SubmitChanges()를 사용 하여 데이터베이스 에 제출 합 니 다.

NorthwindDataContext db = new NorthwindDataContext();
var newCustomer = new Customer
{
    CustomerID = "MCSFT",
    CompanyName = "Microsoft",
    ContactName = "John Doe",
    ContactTitle = "Sales Manager",
    Address = "1 Microsoft Way",
    City = "Redmond",
    Region = "WA",
    PostalCode = "98052",
    Country = "USA",
    Phone = "(425) 555-1234",
    Fax = null
};
db.Customers.InsertOnSubmit(newCustomer);
db.SubmitChanges();

구문 설명:InsertOnSubmit 방법 으로 새로운 고객 을 customers 표 대상 에 추가 합 니 다.SubmitChanges 를 호출 하여 이 새 Customer 를 데이터베이스 에 저장 합 니 다.
2.한 쌍 의 다 중 관계
설명:Category 와 Product 은 한 쌍 이상 의 관계 로 Category(한 쪽)의 데 이 터 를 제출 할 때 LINQ to SQL 은 자동 으로 Product(여러 쪽)의 데 이 터 를 함께 제출 합 니 다.

var newCategory = new Category
{
    CategoryName = "Widgets",
    Description = "Widgets are the ……"
};
var newProduct = new Product
{
    ProductName = "Blue Widget",
    UnitPrice = 34.56M,
    Category = newCategory
};
db.Categories.InsertOnSubmit(newCategory);
db.SubmitChanges();

구문 설명:InsertOnSubmit 방법 을 사용 하여 새 분 류 를 Categories 표 에 추가 하고 새 제품 대상 을 이 새 Category 와 외부 키 관계 가 있 는 Products 표 에 추가 합 니 다.SubmitChanges 를 호출 하여 이 새로운 대상 과 그 관 계 를 데이터베이스 에 저장 합 니 다.
3.다 대 다 관계
설명:다 중 관계 에서 우 리 는 순서대로 제출 해 야 한다.

var newEmployee = new Employee
{
    FirstName = "Kira",
    LastName = "Smith"
};
var newTerritory = new Territory
{
    TerritoryID = "12345",
    TerritoryDescription = "Anytown",
    Region = db.Regions.First()
};
var newEmployeeTerritory = new EmployeeTerritory
{
    Employee = newEmployee,
    Territory = newTerritory
};
db.Employees.InsertOnSubmit(newEmployee);
db.Territories.InsertOnSubmit(newTerritory);
db.EmployeeTerritories.InsertOnSubmit(newEmployeeTerritory);
db.SubmitChanges();

구문 설명:Inserton Submit 방법 으로 새 직원 을 Employees 표 에 추가 하고 새 Territory 를 Territories 표 에 추가 하 며 새 EmployeTerritory 대상 을 새 Employee 대상 과 새 Territory 대상 과 외부 키 관계 가 있 는 EmployeTerritories 표 에 추가 합 니 다.SubmitChanges 를 호출 하여 이 새로운 대상 과 관 계 를 데이터베이스 에 유지 합 니 다.
4.동적 CUD 재 작성 사용(동적 CUD 를 사용 하여 오 버 라 이 드)
설명:CUD 는 Create,Update,Delete 의 줄 임 말이다.아래 의 예 는 ID(메 인 키)가 32 인 Region 을 새로 만 드 는 것 입 니 다.데이터베이스 에 ID 가 32 인 데이터 가 있 는 지 없 는 지 를 고려 하지 않 고 있 으 면 원래 의 데 이 터 를 교체 하고 없 으 면 삽입 합 니 다.

Region nwRegion = new Region()
{
    RegionID = 32,
    RegionDescription = "Rainy"
};
db.Regions.InsertOnSubmit(nwRegion);
db.SubmitChanges();

구문 설명:DataContext 가 제공 하 는 부분 별 방법 인 InsertRegion 을 사용 하여 영역 을 삽입 합 니 다.SubmitChanges 호출 은 InsertRegion 을 호출 하여 다시 쓰 고,후 자 는 동적 CUD 를 사용 하여 Linq To SQL 을 실행 하여 생 성 된 기본 SQL 조 회 를 실행 합 니 다.
업데이트(업데이트)
설명:업데이트 작업 은 대상 을 먼저 가 져 오고 수정 작업 을 한 후에 SubmitChanges()방법 을 직접 호출 하면 제출 할 수 있 습 니 다.여 기 는 같은 DataContext 에서 서로 다른 DataContex 에 대해 아래 의 설명 을 보십시오.
1.단순 형식

Customer cust =
    db.Customers.First(c => c.CustomerID == "ALFKI");
cust.ContactTitle = "Vice President";
db.SubmitChanges();

구문 설명:SubmitChanges 를 사용 하여 검색 한 Customer 대상 에 대한 업 데 이 트 를 데이터베이스 로 유지 합 니 다.
2.여러 가지 변경

var q = from p in db.Products
        where p.CategoryID == 1
        select p;
foreach (var p in q)
{
    p.UnitPrice += 1.00M;
}
db.SubmitChanges();

구문 설명:SubmitChanges 를 사용 하여 검색 한 업 데 이 트 를 데이터베이스 로 유지 합 니 다.
삭제(삭제)
1.단순 형식
설명:DeleteOnSubmit 방법 을 호출 하면 됩 니 다.

OrderDetail orderDetail =
    db.OrderDetails.First
    (c => c.OrderID == 10255 && c.ProductID == 36);
db.OrderDetails.DeleteOnSubmit(orderDetail);
db.SubmitChanges();

구문 설명:OrderDetail 표 에서 OrderDetail 대상 을 삭제 하 는 deleteOnSubmit 방법 을 사용 합 니 다.SubmitChanges 를 호출 하여 이 삭 제 를 데이터베이스 에 유지 합 니 다.
2.한 쌍 의 다 중 관계
설명:Order 와 Order Detail 은 한 쌍 의 다 중 관계 입 니 다.먼저 deleteOnSubmit 의 Order Detail(다 중),그 다음 에 deleteOnSubmit 의 Order(한 끝)입 니 다.한쪽 은 메 인 키 니까.

var orderDetails =
    from o in db.OrderDetails
    where o.Order.CustomerID == "WARTH" &&
    o.Order.EmployeeID == 3
    select o;
var order =
    (from o in db.Orders
     where o.CustomerID == "WARTH" && o.EmployeeID == 3
     select o).First();
foreach (OrderDetail od in orderDetails)
{
    db.OrderDetails.DeleteOnSubmit(od);
}
db.Orders.DeleteOnSubmit(order);
db.SubmitChanges();

구문 설명 문 설명:Order 와 Order Details 표 에서 Order 와 Order Detail 대상 을 삭제 합 니 다.먼저 Order Details 에서 삭제 한 다음 Orders 에서 삭제 합 니 다.SubmitChanges 를 호출 하여 이 삭 제 를 데이터베이스 에 유지 합 니 다.
3.추리 삭제(추 정 된 삭제)
설명:Order 와 Order Detail 은 한 쌍 의 다 중 관계 입 니 다.위의 예 에서 저 희 는 CustomerID 가 WARTH 와 EmployeeID 가 3 인 데 이 터 를 모두 삭제 합 니 다.그러면 저 희 는 모두 삭제 하지 않 아 도 됩 니까?예 를 들 어 Order 의 Order ID 가 10248 인 Order Detail 은 매우 많 지만 저 희 는 ProductID 가 11 인 Order Detail 만 삭제 하면 됩 니 다.이때 Remove 방법 을 사용 합 니 다.

Order order = db.Orders.First(x => x.OrderID == 10248);
OrderDetail od = 
    order.OrderDetails.First(d => d.ProductID == 11);
order.OrderDetails.Remove(od);
db.SubmitChanges();

구문 설명 문 설명:이 예 는 실체 대상 의 인용 실체 가 이 대상 을 EntitySet 에서 제거 할 때 이 대상 에서 어떻게 실제 삭제 작업 을 하 는 지 추리 하 는 것 을 설명 합 니 다.실체의 관련 맵 이 DeleteOnNull 을 true 로 설정 하고 CanBeNull 을 false 로 설정 할 때 만 추리 삭제 행위 가 발생 합 니 다.
Attach 업데이트 사용(Attach 로 업데이트)
설명:서로 다른 DataContext 사이 에서 Attach 방법 으로 데 이 터 를 업데이트 합 니 다.예 를 들 어 tempdb 라 는 NorthwindDataContext 에서 Customer 와 Order 를 조회 하고 다른 NorthwindDataContext 에서 Customer 의 주 소 는 123 First Ave 로 업데이트 되 며 Order 의 CustomerID 는 CHOPS 로 업데이트 된다.

//  ，           XML          
//         DataContext      DataContext
//               ，            
Customer c1;
List<Order> deserializedOrders = new List<Order>();
Customer deserializedC1;
using (NorthwindDataContext tempdb = new NorthwindDataContext())
{
    c1 = tempdb.Customers.Single(c => c.CustomerID == "ALFKI");
    deserializedC1 = new Customer
    {
        Address = c1.Address,
        City = c1.City,
        CompanyName = c1.CompanyName,
        ContactName = c1.ContactName,
        ContactTitle = c1.ContactTitle,
        Country = c1.Country,
        CustomerID = c1.CustomerID,
        Fax = c1.Fax,
        Phone = c1.Phone,
        PostalCode = c1.PostalCode,
        Region = c1.Region
    };
    Customer tempcust =
        tempdb.Customers.Single(c => c.CustomerID == "ANTON");
    foreach (Order o in tempcust.Orders)
    {
        deserializedOrders.Add(new Order
        {
            CustomerID = o.CustomerID,
            EmployeeID = o.EmployeeID,
            Freight = o.Freight,
            OrderDate = o.OrderDate,
            OrderID = o.OrderID,
            RequiredDate = o.RequiredDate,
            ShipAddress = o.ShipAddress,
            ShipCity = o.ShipCity,
            ShipName = o.ShipName,
            ShipCountry = o.ShipCountry,
            ShippedDate = o.ShippedDate,
            ShipPostalCode = o.ShipPostalCode,
            ShipRegion = o.ShipRegion,
            ShipVia = o.ShipVia
        });
    }
}
using (NorthwindDataContext db2 = new NorthwindDataContext())
{
    //                ，     
    // Customer  ，    
    db2.Customers.Attach(deserializedC1);
    //        
    deserializedC1.Address = "123 First Ave";
    //            
    db2.Orders.AttachAll(deserializedOrders);
    //            
    foreach (Order o in deserializedOrders)
    {
        o.CustomerID = "CHOPS";
    }
    //             
    db2.SubmitChanges();
}

구문 설명:다른 층 에서 실 체 를 가 져 오고 Attach 와 AttachAll 을 사용 하여 역 직렬 화 된 실 체 를 데이터 컨 텍스트 에 추가 한 다음 실 체 를 업데이트 합 니 다.변경 사항 이 데이터베이스 에 제출 되 었 습 니 다.
Attach 업데이트 및 삭제 사용(Update and Delete with Attach)
설명:서로 다른 DataContext 에서 삽입,업데이트,삭 제 를 실현 합 니 다.다음 의 예 를 보십시오.

//  ，          XML        
//      LoadWith                ，
//       
Customer cust = null;
using (NorthwindDataContext tempdb = new NorthwindDataContext())
{
    DataLoadOptions shape = new DataLoadOptions();
    shape.LoadWith<Customer>(c => c.Orders);
    //             
    tempdb.LoadOptions = shape;
    tempdb.DeferredLoadingEnabled = false;
    cust = tempdb.Customers.First(x => x.CustomerID == "ALFKI");
}
Order orderA = cust.Orders.First();
Order orderB = cust.Orders.First(x => x.OrderID > orderA.OrderID);
using (NorthwindDataContext db2 = new NorthwindDataContext())
{
    //                ，     
    db2.Customers.Attach(cust);
    //           ;            
    db2.Orders.AttachAll(cust.Orders.ToList());
    //     Phone.
    cust.Phone = "2345 5436";
    //       OrderA ShipCity.
    orderA.ShipCity = "Redmond";
    //       OrderB.
    cust.Orders.Remove(orderB);
    //        Order   Customer .
    Order orderC = new Order() { ShipCity = "New York" };
    cust.Orders.Add(orderC);
    //    
    db2.SubmitChanges();
}

구문 설명:하나의 컨 텍스트 에서 실 체 를 추출 하고 Attach 와 AttachAll 을 사용 하여 다른 컨 텍스트 에서 온 실 체 를 추가 한 다음 에 이 두 실 체 를 업데이트 하고 하나의 실 체 를 삭제 하 며 다른 실 체 를 추가 합 니 다.변경 사항 이 데이터베이스 에 제출 되 었 습 니 다.
원문