Shorty's Development Diary

public void InsertEmployee(Employee newEmployee) {...}

[Insert]

public void YourFavoriteMethodName(Employee newEmployee) {...}

public void UpdateEmployee(Employee changedEmployee, Employee

              originalEmployee)

[Update]

public void YourFavoriteMethodName(Employee changedEmployee, Employee

                                    originalEmployee)

public void DeleteEmployee(Employee currentEmployee, Employee

                     originalEmployee)

[Delete]

public void YourFavoriteMethodName(Employee currentEmployee, Employee

                                           originalEmployee)

public IQueryable<Employee> GetEmployee() {...}

[Query]

public IQueryable<Employee> GetEmployee() {...}

[Query(PreserveName=true)]

public IQueryable<Employee> GetEmployee() {...}

 public void ApproveEmployee(Employee changedEmployee, ...)

[Custom]

public void ApproveEmployee(Employee changedEmployee, ...)

public bool ResolveEmployee(PurchaseOrder currentEmployee, PurchaseOrder originalEmployee, PurchaseOrder storeEmployee, bool deleteOperation)

[ServiceOperation]

public byte[] GetProductImage(){...}

[IgnoreOperation]

public void InsertEmployee(Employee newEmployee) {...}

using System.Windows.Ria.Data;

using CustomSample.Web;

namespace CustomSample

{

    public partial class MainPage : UserControl

    {

        Catalog catalog = new Catalog();

        public MainPage()

        {

            InitializeComponent();

            productsGrid.ItemsSource = catalog.Products;

            catalog.LoadProducts(Catalog.ProductsQuery.Where(p => p.ListPrice > 3000), null);

        }

    }

}

        [Custom]

        public void DiscountProduct(Product product, int percentage)

        {

            this.Context.Products.Attach(product);

            product.ListPrice = product.ListPrice * (1 - percentage / 100m);

            string logMessage = String.Format("{0} has been marked down {1}% on {2}",

                product.Name, percentage, DateTime.Now);

            string logFilePath = HttpContext.Current.Server.MapPath("log.txt");

            using (StreamWriter streamWriter = new StreamWriter(logFilePath, true))

            {

                streamWriter.WriteLine(logMessage);

                streamWriter.Flush();

                streamWriter.Close();

            }

        }

        public MainPage()

        {

          //Some Initializaiton logic...           

            discountButton.Click += new RoutedEventHandler(discountButton_Click);

        }

        void discountButton_Click(object sender, RoutedEventArgs e)

        {

            Product selectedProduct = (Product)productsGrid.SelectedItem;

            int percentage = int.Parse(discountPercent.Text);

            catalog.DiscountProduct(selectedProduct, percentage);

            catalog.SubmitChanges();

        }

        [ServiceOperation]

        public string GetIP()

        {

            return HttpContext.Current.Request.UserHostAddress;

        }

        public MainPage()

        {

            //Some initialization logic...

            catalog.GetIPCompleted += new EventHandler<InvokeEventArgs>(catalog_GetIPCompleted);

            catalog.GetIP();

        }

        void catalog_GetIPCompleted(object sender, InvokeEventArgs e)

        {

            userIP.Text = (string)e.ReturnValue;

        }

[MainPage.XAML.CS]

using UpdateSample.Web;

using System.Windows.Ria.Data;

namespace UpdateSample {

    public partial class MainPage : UserControl {

        Catalog _catalog = new Catalog();

        public MainPage() {

            InitializeComponent();

            productsGrid.ItemsSource = _catalog.Products;

            var query = from p in _catalog.GetProductsQuery()

                        where p.ProductSubcategoryID == 1

                        select p;

            _catalog.Load(query);

        }

    }

}

수정 (2009.8.18 : LoadProduct -> Load로 함수변경. 쿼리사용하는 것으로 변경)

    [EnableClientAccess()]

    public class Catalog : LinqToSqlDomainService<AdventureWorksDataContext> {

        public IQueryable<Product> GetProducts() {

            return this.Context.Products;

        }

        public void InsertProduct(Product product) {

            this.Context.Products.InsertOnSubmit(product);

        }

        public void UpdateProduct(Product currentProduct, Product originalProduct) {

            this.Context.Products.Attach(currentProduct, originalProduct);

        }

        public void DeleteProduct(Product product) {

            this.Context.Products.Attach(product, product);

            this.Context.Products.DeleteOnSubmit(product);

        }

}

       public MainPage() {

            InitializeComponent();

            UpdateHasChanges();

            productsGrid.RowEditEnded +=

         new EventHandler<DataGridRowEditEndedEventArgs>(productsGrid_RowEditEnded);

    catalog.Submitted += new EventHandler<SubmittedChangesEventArgs>(catalog_Submitted);

            productsGrid.ItemsSource = catalog.Products;

            catalog.LoadProducts(

        Catalog.ProductsQuery.Where(p => p.ProductSubcategoryID == 1), null);

        }

void catalog_Submitted(object sender, SubmittedChangesEventArgs e) {

            UpdateHasChanges();

        }

        void productsGrid_RowEditEnded(object sender, DataGridRowEditEndedEventArgs e) {

            // every time a row is updated, update the change state

            UpdateHasChanges();

        }

        private void UpdateHasChanges() {

            // get the current changeset from the EntityContainer

            EntityChangeSet changeSet = catalog.Entities.GetChanges();

            changeText.Text = changeSet.ToString();

            // update the button states

            bool hasChanges = catalog.HasChanges;

            saveButton.IsEnabled = hasChanges;

            rejectButton.IsEnabled = hasChanges;

}

        private void rejectButton_Click(object sender, RoutedEventArgs e) {

            catalog.RejectChanges();

            UpdateHasChanges();

        }

        private void saveButton_Click(object sender, RoutedEventArgs e) {

            catalog.SubmitChanges();

            UpdateHasChanges();

        }

EntityChangeSet changeSet = catalog.Entities.GetChanges();

private void rejectButton_Click(object sender, RoutedEventArgs e) {

            catalog.RejectChanges();

            UpdateHasChanges();

        }

void catalog_Submitted(object sender, SubmittedChangesEventArgs e) {

            if (e.Error != null) {

                string message = string.Empty;

                if (e.EntitiesInError != null) {

                    Entity entityInError = e.EntitiesInError.First();

                    if (entityInError.Conflict != null) {

                        EntityConflict conflict = entityInError.Conflict;

                        foreach (EntityConflictMember cm in conflict.MemberConflicts) {

                            message += string.Format(

                                "Member '{0}' in conflict: Current: {1}, Original: {2}, Store: {3}",

                                cm.PropertyName, cm.CurrentValue, cm.OriginalValue, cm.StoreValue);

                        }

                    } else if (entityInError.ValidationErrors.Count > 0) {

                        message += "\r\n" + entityInError.ValidationErrors.First().Message;

                    }

                }

                MessageBox.Show(message, "Submit Failed", MessageBoxButton.OK);

            }

            else {

                UpdateHasChanges();

            }

        }

        public void UpdateProduct(Product currentProduct, Product originalProduct) {

            if (currentProduct.ListPrice == 0) {

                throw new ValidationException("List price must be greater than zero!");

            }

            this.Context.Products.Attach(currentProduct, originalProduct);

        }

        public bool ResolveProduct(Product currentProduct, Product originalProduct, Product storeProduct, bool deleteOperation)   

        {

            return this.Resolve(currentProduct, originalProduct, storeProduct, ResolveOption.KeepChanges);

        }

public override void Submit(ChangeSet changeSet) {

            using (var tx = new TransactionScope(

                TransactionScopeOption.Required,

                new TransactionOptions { IsolationLevel = IsolationLevel.ReadCommitted })

                ) {

                // call to base to process the changeset within

                // our transaction scope

                base.Submit(changeSet);

                // complete the transaction

                tx.Complete();

            }

        }

public override object GetIdentity()

        {

            return this._productID;

        }

namespace System.ComponentModel {

            public interface IEditableObject {

               void BeginEdit();

               void CancelEdit();

               void EndEdit();

        }

       namespace System.ComponentModel {

            public interface IChangeTracking {

                bool IsChanged { get; }

                void AcceptChanges();

            }

            public interface IRevertibleChangeTracking : IChangeTracking {

                void RejectChanges();

            }

        }

namespace System.ComponentModel {

    public interface IEditableCollection {

        bool CanAdd { get; }

        bool CanEdit { get; }

        bool CanRemove { get; }

        void Add(object item);

        void BeginEdit(object item);

        void CancelEdit(object item);

        object CreateNew();

        void EndEdit(object item);

        void Remove(object item);

    }

}