This example creates a new control which derives from FrameworkElement and is very similar to the implementation of the Viewport3D control. The new control overrides the measure and layout methods of FrameworkElement and positions the child controls (supplied as a collection of UIElements) according to the orientation of an imaginary 2D ellipse in 3D space.

It is assumed that the reader has some knowledge of custom controls, LINQ and 3D in WPF. The code provided is by no means an ideal implementation of the theory, it should be thought of more as a quick demonstration of the concept. And remember, in WPF there is almost always more than one way of doing the same thing, mine is just my take on the problem :0)

The Idea

In the last example, we worked out how to lay out controls as if they were positioned at equal intervals around the edge of an imaginary ellipse. We now want to take that ellipse from a 2D space in to 3D, giving a sense of depth in the control.

Taking the existing layout logic in to the third dimension is fairly trivial if we remember that the positions we calculate for child controls in the 2D version could be thought of as being 3D points, all at the same distance away from the screen, i.e. z = 0. So by treating the points that are generated as 3D points, each with a value of zero for z (their depth), we can then rotate them to match the orientation of the layout ellipse (defined by an x, y and z axis rotation).

In short, we calculate the position of each child element as before, then rotate that point in 3D to match the rotation of a virtual layout ellipse. The layout ellipse will be configured as before, although this time we need to allow a way to configure its orientation. This is as simple as adding three new properties to allow an angle of rotation to be specified for each axis.

When it comes to the control, we need to look to 3D controls in WPF. We could create our own control which lays out its content, then projects it in to 3D and renders the control scaled such that they appear to be 3D, but that's no fun and way too much effort! It would somehow be great if we could take advantage of the relatively new Viewport2DVisual3D control, effictively a 3D wrapper for a UIElement. It would also be great if the control exposed just a collection of UIElements, which internally it could wrap in a Viewport2DVisual3D control. 

Now we know what our items are doing, we need to think of a suitable container. If we look at the Viewport3D control, we can see that it wraps a Viewport3DVisual, exposing a collection of UIElement objects which it implicitly converts to Visual3D objects and adds to the inner Viewport3DVisual, as well as one or two other things. This is very similar to what we want to do, with the difference that we want to also define the layout mechanism too.

The Theory

I guess the first thing to tackle here is how to take the generated 2D position for each child control and turn that in to a 3D point, which we can use to create a TranslateTransform3D. For each point we generate on the ellipse, create a Point3D object using the x and y values of the 2D point and supply a z value of 0d (or whatever you want for the ellipse's distance from the image plane).

Next, rotate the point around each axis using the rotations used to describe the layout ellipse's orientation.  If you're familiar with 3D graphics you may well be aware of Gimbal lock, something we want to avoid when we're rotating the child control positions. To combat this, the rotation method will use quaternions. If you've not come across quaternions before, I recommend a quick look on Google as there are far better explanations out there than I can give. Also look at this site which gives the theory behind the math used to rotate a point.

[sourcecode language='csharp']
private readonly static Vector3D UnitXAxis3D = new Vector3D(1d, 0d, 0d);
private readonly static Vector3D UnitYAxis3D = new Vector3D(0d, 1d, 0d);
private readonly static Vector3D UnitZAxis3D = new Vector3D(0d, 0d, 1d);

private static Point3D RotatePoint3D(Point3D point, double xRotation, double yRotation, double zRotation)
{
Quaternion xQ = new Quaternion(UnitXAxis3D, xRotation);
Quaternion yQ = new Quaternion(UnitYAxis3D, yRotation);
Quaternion zQ = new Quaternion(UnitZAxis3D, zRotation);

Quaternion xyzQ = xQ * yQ * zQ;
Quaternion xyzQc = xyzQ;
xyzQc.Conjugate();

Quaternion pQ = new Quaternion(point.X, point.Y, point.Z, 0d);
Quaternion q = xyzQ * pQ * xyzQc;
Point3D rotatedPoint = new Point3D(q.X, q.Y, q.Z);

return rotatedPoint;
}
[/sourcecode]

With the Point3D in hand, a TranslateTransform3D object can be created and applied to the child Viewport2DVisual3D control. This leads to the next question of how we are going to handle the wrapping of UIElements. With the addition of the Viewport2DVisual3D control, it is now possible to easily use a UIElement in a 3D scene, maintaining all the usual input handling, so no more messing around with visual brushes and models! You don't get off too lightly though as you still need to provide the Viewport2DVisual3D with some information. This includes a Geometry3D object detailing a mesh that defines the surface which the inner Visual is to be rendered on; the material which should be used when rendering the Visual on the mesh and finally the Visual object itself.

To keep things simple, we can define a basic mesh containing a unit square. This mesh is going to be used as the geometry for each control surface, so we need a way of sizing it according to the dimensions of the control being rendered. This is again a trivial problem and is solved by creating a ScaleTransform3D object which scales the Viewport2DVisual3D control so that it is scaled by the dimensions of the inner Visual object, ignoring z. Nice!

The scale transform is created for each Viewport2DVisual3D control each time the MeasureOverride method is called. There is no particular reason to place this code here, other than it keeps the sizing logic separate from the layout logic, keeping things a bit better organised. The next code snippet is included to highlight the use of the OfType<T>() LINQ extension method, used on the Children property of the control's inner Viewport3DVisual. This method returns an IEnumerable<T> object containing all the items in the collection with a type specified by T. Because we know that our Children collection contains a light somewhere within it, we want to skip over that when scaling the child objects.

[sourcecode language='csharp']
protected override Size MeasureOverride(Size availableSize)
{
//Iterate all the children of the inner viewport.
foreach (Viewport2DVisual3D visualChild 
in viewport3DVisual.Children.OfType())
{
//Get the inner UIElement
UIElement element = visualChild.Visual as UIElement;
//Create a scale transform so that the control appears the right size
ScaleTransform3D scaleTransform
= new ScaleTransform3D(element.DesiredSize.Width, element.DesiredSize.Height, 0d);

//Add the scale transform in to the Viewport2DVisual3D's transform group.
AssertTransform3D(scaleTransform, visualChild);
}

return availableSize;
}
[/sourcecode]

The container that will hold all of these Viewport2DVisual3D controls will need to be a Viewport3DVisual. Again because we are dealing with 3D we need to define a few extra things for the Viewport3DVisual. The first is a Camera object which defines how controls displayed in the Viewport3DVisual appear to the viewer. The second is a Light object which defines an AmbientLight object used to provide a uniform white light in the 3D scene (otherwise everything would be dark and you'd see nothing more than a black screen).

To make the controls appear to be positioned within 3-dimensional space, we will use a PerspectiveCamera, meaning objects which are placed deeper in to the control (further from the screen) will appear smaller than those which are closer to the screen. All we need to do to configure the camera is tell it where it is and the direction it is looking. Because we are keeping things simple here, we'll position our camera somewhere along the positive z-axis, and have it looking down the z-axis (towards the origin). This means our camera will be looking straight on at the objects placed within the control, with the layout ellipse's origin at the origin of the scene.

The Solution

Here I present a simple demonstration of the above in the attached solution. The solution contains a simple Window which hosts the custom 3D ellipse layout control. The ellipse layout control is included in the ElliptiseLayout3DPanel class and adds several dependency properties and a few methods to the FrameworkElement class.

The main window also contains a few controls which allow you to interact with the layout control, allowing you to specify the size, location and pose of the layout control as well as add or remove items to the control. There are also two buttons will moves the controls around the ellipse, one at a time. This is a bit of a jig and is as simple as removing an item from the top of the collection held in the control's Children property and adding it to the end of the collection. The reverse is true for moving back through the items. The light sometimes gets caught up in this, so you may not see anything happen for a click or two when switching direction.

With the default orientation of the ellipse when the demo app first runs, changes made to the z-rotation slider will have the effect of spinning the controls around, in the fashion of a carousel. This could be used to animate the rotation items in the control.

To the right is a class diagram, showing the structure of the layout control. You can see it’s pretty simple and doesn’t need to add much to its FrameworkElement ancestor. 

Below is a screen-shot of the demo application in action. The values of the sliders are directly bound to the panel’s dependency properties, meaning the only code-behind is for the four button event handlers.

The code is available for download as a Visual Studio 2008 (SP1) solution, built against .Net 3.5 SP1.

Going Forwards

The light source and other properties of the control are not configurable. You may want to expose the lights as a separate collection, or at least allow the colour to be altered.

The control will need some more work to enable it to be used in an ItemsPanelTemplate, so it won't work out of the box.

You may want to add proper methods for controlling the order of items in the control, possibly animating this.

All and any comments / bugs / suggestions are welcomed!

At the time of writing this post, .NET has no specific facility to work with REST services. Though, some services over the web provide information in REST format. For example, http://www.geonames.org (that provides gegraphic information) has a lot of free web services to get geographical information. The other day, I needed to use these services to let the end user choose his/her country and then state from two drop-down lists. So I had to figure out how to consume such services. In this post we will use the following service as an case-study:

http://ws.geonames.org/countryInfo?lang=it&country=DE

If you navigate to this link you will get the following result:

As is seen, the resulting XML is pretty straight forward.  With knowing that REST web services work with GET and POST methods, it is nearly nothing except working with xml!

For example, to query a REST service, like the one I mentioned above, we can use LINQ's XAML functionality.  The XElement class (declared in System.Linq.XML) provides a Load method that can retrieve an XML data from a url with GET  method:

XElement rootXml = XElement.Load("http://ws.geonames.org/countryInfo?lang=it&country=DE");

var Countries = from C in rootXml.Elements()
select new { Code = (string)C.Element("countryCode"),
Name = (string)C.Element("countryName") };
foreach (var x in Countries)
Console.WriteLine("{0}  {1}", x.Code, x.Name);
Console.ReadKey();

After retrieveing the full xml, you can extract any kind of information you want. no matter how complex is it!

Adding or modifying information using POST method is a bit more complex. First we have to obtain a channel by which we may POST the information. Then we have to create an instance of data entity in XML format. Finally we have to POST data through the channel.

To get access to REST service we use a HttpWebRequest since it let's use the POST method and let us specify the type of information we are posting.

HttpWebRequest channel = (HttpWebRequest)WebRequest.Create("http://ws.geonames.org/countryInfo");
channel.Method = "POST";
channel.ContentType = "text/xml";

HttpWebRequest class provides a stream to which we can write information :

StreamWriter sw = new StreamWriter(channel.GetRequestStream());

Then we can create a concerete entity to post:

XElement country = new XElement("country" ,

new XElement("countryCode", "AUS"),

new XElement("countryName" , "Australia"),

....

);

Finally we just need to save this XElement object to the stream we obtained from HttpWebRequest:

country.Save(sw);

This post shows how to deal with REST web services, or any other resource that let us work it in a POST/GET manner. Thanks to Linq to XML working with such services is now too easy.

Aparte de la noticia de la RC1 de LINQ4SP, creo que también es destacable que esta extensión de LINQ para SharePoint no esté incluida en el proyecto original de Codeplex, lo que creo que va en la dirección de que la versión final de LINQ4SP será de pago...veremos que pasa en el futuro. En cualquier caso, esta RC1 es una excelente oportunidad de probar las prestaciones de LINQ4SP.

Introduction

LINQ (short for Language INtegrated Query) is an extension to .NET languages. It allows us developers to query different sources of data.

Why do we need it?

In enterprise application development, we frequently face the need to query data. The data could be present in

• CSV
• XML
• .NET Collections
• SQL Server, Oracle, MySQL, PostgreSQL and the list goes on

For each of these data sources we need to resort to a querying API that is specific to the data source. For example XPath, XQuery, T-SQL, PL/SQL

LINQ aims to facilitate .NET developers by providing a querying API that is baked right into our favorite programming languages (i.e. C#, VB etc.) and can be extended to provide querying support to any data source. This provides a number of benefits:

• Reduced learning curve
• Reduced training costs
• Reduced risk due to type checking at compile time
• Less amount of rework in case of switching back-end data source

LINQ can be extended by using a provider pattern. Currently the following providers are available out of the box.

• LINQ to SQL
• LINQ to DataSet
• LINQ to Objects
• LINQ to Xml
• LINQ to Entities

We’ll have a look at each of these individually in forthcoming posts.

How to LINQ?

Using LINQ effectively requires us to learn some other new features that LINQ is built upon and that are also introduced in .NET 3.0. These include:

• Anonymous types
• Lambdas
• Object Initializer
• Extension Methods

In the next post I’ll cover these features and we’ll further explore LINQ in the following posts.

Bye for now

Tôi đã khắc khoải chờ đợi ngày Dynamic Data được phát hành. Và giờ thì nó đây (đã được phát hành cùng với VS 2008 và .NET 3.5 SP1) Tôi quyết định thử xem nó có gì bằng cách thử tạo một ứng dụng web Dynamic Data cho phép bạn duyệt qua 5 bảng chính có trong CSDL Northwind: Customers, Employees, Orders, Products and Suppliers. Hãy đọc một cách chi tiết và dừng quên download mã nguồn.  Dịch vụ DiscountASP hiện chưa hoàn toàn nâng cấp lên SP1 nên tôi không thể cài một bản demo cho chương trình này. Hi vọng là họ sẽ nâng cấp sớm, nhưng tôi cũng đảm bảo là sẽ có nhiều ảnh chụp màn hình để bạn có thể xem và thấy được nó thế nào.

Dynamic Data là gì?

Tôi luôn theo sát ASP.NET, nhưng tôi không biết là Dynamic Data đã được đưa vào bản SP1. Tôi hỏi một số đồng nghiệp và họ cũng tỏ vẻ ngạc nhiên. Và không ít người thậm chí chưa từng nghe về Dynamic Data. Nếu bạn rơi vào trường hợp này, thì vài đoạn trích dẫn dau đây sẽ mô tả Dynamic Data là gì.

Từ Wikipedia ...

ASP.NET Dynamic Data is a web application scaffolding framework from Microsoft, shipped as an extension to ASP.NET, that can be used to build data driven web applications. It exposes tables in a database by encoding it in the URI of the ASP.NET web service, and the data in the table is automatically rendered to HTML. The process of rendering can be controlled using custom design templates. Internally, it discovers the database schema by using the database metadata. (nguyên gốc)

From asp.net ...

ASP.NET Dynamic Data provides a framework that enables you to quickly build a functional data-driven application, based on a LINQ to SQL or Entity Framework data model. It also adds great flexibility and functionality to the DetailsView, FormView, GridView, and ListView controls in the form of smart validation and the ability to easily change the display of these controls using templates.(nguyên gốc)

Nôm na ASP.NET Dynamic Data là một bộ khung cho phép xây dựng các ứng dụng nặng về dữ liệu, dựa trên LINQ to SQL hoặc Entity Framework. Dựa trên cấu trúc của CSDL mà Dynamic Data Framework (DDF)  sẽ tạo nên các trang web cho phép người dùng xem/chèn/xóa/sửa dữ liệu. Ngoài ra, nó còn cho phép tùy biến để người dùng có thể thêm vào các cơ chế kiểm tra tính hợp lệ của dữ liệu, hoặc chỉnh sửa lại các mẫu để thay đổi cách hiển thị dữ liệu - NG.

Và với chương trình mẫu này, tôi sẽ dùng Dynamic Data để tạo một ứng dụng web cho phép tôi duyệt qua CSDL Northwind.

Tạo một website Dynamic Data

Để bắt đầu, bạn hãy chọn File -> New -> Web Site và chọn Dynamic Data Entities Web Site hay Dynamic Data Web Site. Nếu bạn đang định dùng ADO.NET Entity Framework để truy cập dữ liệu thì chọn cái thứ nhất, ngược lại, nếu dùng LINQ to SQL thì hãy chọn cái thứ hai. Với ví dụ này tôi sẽ dùng LINQ to SQL, do vậy tôi chọn Dynamic Data Web Site.

Khi VS đã tạo xong, bạn sẽ thấy một số file/folder được đưa vào trong solution. Trong đó sẽ có một folder có tên là DynamicData, bên trong chứa một số các folder khác, và trong mỗi folder con này sẽ chứa các UserControl và các trang ASP.NET.

Tạo và đăng ký LINQ to SQL DataContext

Tôi dự định dùng LINQ to SQL để truy cập vào CSDL Northwind, vậy nên tôi dùng VS designer để tạo các lớp LINQ to SQL cho các bảng tôi muốn bằng cách kéo các bảng này từ Server Explorer và thả nó lên trên trình thiết kế LINQ to SQL.

Sau khi tạo ra DataContext, tôi cập nhật file Global.asax và đăng ký NorthwindDataContext với hệ thống DynamicData. Website được tạo ra đã chứa sẵn mã lệnh để làm những điều này, bạn chỉ cần đọc các đoạn ghi chú và sửa lại code theo cách bạn muốn. Và sau khi chỉnh sửa, nó sẽ trông như sau:

   1: public static void RegisterRoutes(RouteCollection routes) {

   2:     MetaModel model = new MetaModel();

   3:

   4:     //                    IMPORTANT: DATA MODEL REGISTRATION 

   5:     // Uncomment this line to register LINQ to SQL classes or an ADO.NET Entity Data

   6:     // model for ASP.NET Dynamic Data. Set ScaffoldAllTables = true only if you are sure 

   7:     // that you want all tables in the data model to support a scaffold (i.e. templates) 

   8:     // view. To control scaffolding for individual tables, create a partial class for 

   9:     // the table and apply the [Scaffold(true)] attribute to the partial class.

  10:     // Note: Make sure that you change "YourDataContextType" to the name of the data context

  11:     // class in your application.

  12:     model.RegisterContext(typeof(NorthwindDataContext), new ContextConfiguration() { ScaffoldAllTables = true });

  13: 

  14:     // The following statement supports separate-page mode, where the List, Detail, Insert, and 

  15:     // Update tasks are performed by using separate pages. To enable this mode, uncomment the following 

  16:     // route definition, and comment out the route definitions in the combined-page mode section that follows.

  17:     routes.Add(new DynamicDataRoute("{table}/{action}.aspx") {

  18:         Constraints = new RouteValueDictionary(new { action = "List|Details|Edit|Insert" }),

  19:         Model = model

  20:     });

  21: 

  22:     // The following statements support combined-page mode, where the List, Detail, Insert, and

  23:     // Update tasks are performed by using the same page. To enable this mode, uncomment the

  24:     // following routes and comment out the route definition in the separate-page mode section above.

  25:     //routes.Add(new DynamicDataRoute("{table}/ListDetails.aspx") {

  26:     //    Action = PageAction.List,

  27:     //    ViewName = "ListDetails",

  28:     //    Model = model

  29:     //});

  30: 

  31:     //routes.Add(new DynamicDataRoute("{table}/ListDetails.aspx") {

  32:     //    Action = PageAction.Details,

  33:     //    ViewName = "ListDetails",

  34:     //    Model = model

  35:     //});

  36: }

Và sau khi hoàn thành, bạn sẽ có một website trông rất "xinh" và nhiều tính năng. Trên trang chính sẽ hiện ra tất cả các bảng mà bạn có:

Và các trang để xem nội dung chứa trong các bảng (cho phép sắp xếp và phân trang):

Và cả các trang để nhập thêm, cập nhật và xem chi tiết:

Tùy biến

Nếu tôi đã hài lòng với những gì các trang mặc nhiên có, tôi có thể ngừng tại đây và có một ứng dụng web hỗ trợ đầy đủ các thao tác CRUD (create, read, update, delete). Thật tuyệt, và bạn chỉ mất có 5 phút. Nhưng liệu tôi có thể thay đổi một số thứ không?

Tùy biến List Page Template

List template được đặt trong  folder DynamicData/PageTemplates. Trang List mặc nhiên trông đã khá tốt rồi, nhưng tôi vẫn muốn thử xem liệu có thể thay đổi một vài thứ hay không. Vậy nên tôi mởi file List.aspx và thực hiện một số thay đổi.

• Đầu tiên, tôi thêm một viền đen bằng cách đặt GridView vào trong một dãy các thẻ DIV dùng hình nền để tạo kiểu cho đường viền. 
• Tiếp theo, tôi tăng PageSize từ 10 lên 15.
• Sau đó thêm một Data Pager.
• Cuối cùng, tôi muốn trang web này là chỉ đọc, nên tôi xóa các liên kết Insert, Edit và Delete.

Chỉ là những thay đổi nhỏ, nhưng giao diện đã được cải tiến.

Tùy biến Details Page Template

Tiếp theo, tôi thay đổi trang Details một chút theo cách tương tự.

Thêm Custom Metadata vào Model

Có một vài thay đổi sẽ làm bạn thấy các trang của tôi khác với các trang mặc nhiên.

• Số cột khác nhau trong các bảng dữ liệu (các trang của tôi có ít cột hơn)
• Một số tiêu đề cột tên khác
• Một số giá trị trong các ô được định dạng khác
• Tên hiển thị của các bảng

Để tùy biến các mục trên, bạn cần tạo một lớp metadata mà nó sẽ cung cấp cho hệ thống Dynamic Data thông tin về các thực thể của bạn. Thực sự mà nói, tôi không rành phần này lắm, có lẽ vì nó mới. Nhưng dù sao để làm được việc này, bạn cần phải tạo thêm hai lớp nữa cho mỗi lớp trong DataContext. Vậy nên tôi sẽ phải tạo thêm 10 lớp nữa cho 5 bảng dữ liệu của tôi.

Đầu tiên bạn cần tạo thêm một lớp partial với cùng tên của lớp entity trong mô hình dữ liệu và sau đó áp dụng một thuộc tính lên lớp này để có thể chỉ ra lớp metadata cho lớp này. Đoạn code dưới đây sẽ thực hiện điều này cho thực thể Order trong ứng dụng mẫu. The display name for the Order table is 'My Orders' - Applied with the TableName attributes

• Các cột OrderDate, ShippedDate, ShipAddress và ShipCity được thay đổi tên hiển thị bằng cách áp dụng thuộc tính DisplayName.
• Các cột OrderDate và ShippedDate có định dạng được tùy biến- áp dụng bằng thuộc tính DisplayFormat.
• Các cột RequiredDate, ShipVia, Freight, ShipName, ShipPostalCode, và ShipCountry được ẩn bởi khỏi giao diện bằng cách dùng thuộc tính ScaffoldColumn.

1: //  Attach the OrderMetadata to the Order class

   2: [MetadataType(typeof(OrderMetadata))]

   3: public partial class Order {}

   4: 

   5: [TableName("My Orders")]

   6: public class OrderMetadata

   7: {

   8:     //  Override the display name

   9:     [DisplayName("Date Ordered")]

  10:     //  Format the Date

  11:     [DisplayFormat(DataFormatString="{0:d}")]

  12:     public object OrderDate { get; set; }

  13:     //  Override the display name

  14:     [DisplayName("Date Shipped")]

  15:     //  Format the Date

  16:     [DisplayFormat(DataFormatString = "{0:d}")]

  17:     public object ShippedDate { get; set; }

  18:     //  Override the display name

  19:     [DisplayName("Address")]

  20:     public object ShipAddress { get; set; }

  21:     //  Override the display name

  22:     [DisplayName("City")]

  23:     public object ShipCity { get; set; }

  24: 

  25:     //  Columns I want hidden

  26:     [ScaffoldColumn(false)]

  27:     public object RequiredDate { get; set; }

  28:     [ScaffoldColumn(false)]

  29:     public object ShipVia { get; set; }

  30:     [ScaffoldColumn(false)]

  31:     public object Freight { get; set; }

  32:     [ScaffoldColumn(false)]

  33:     public object ShipName { get; set; }

  34:     [ScaffoldColumn(false)]

  35:     public object ShipPostalCode { get; set; }

  36:     [ScaffoldColumn(false)]

  37:     public object ShipCountry { get; set; }

  38: }

Kết luận

 Ok, đây là lần đầu thử qua Dynamic Data. Tôi thực sự hài lòng và tôi sẽ tiếp tục tìm hiểu thêm về nó.

Chúc bạn thành công.

Loạt bài này được dựa trên loạt Tutorial của ScottGu (http://weblogs.asp.net/scottgu).

LINQ to SQL là gì?

LINQ to SQL là một phiên bản hiện thực hóa của O/RM (object relational mapping) có bên trong .NET Framework bản "Orcas" (nay là .NET 3.5), nó cho phép bạn mô hình hóa một cơ sở dữ liệu dùng các lớp .NET. Sau đó bạn có thể truy vấn cơ sở dữ liệu (CSDL) dùng LINQ, cũng như cập nhật/thêm/xóa dữ liệu từ đó.

LINQ to SQL hỗ trợ đầy đủ transaction, view và các stored procedure (SP). Nó cũng cung cấp một cách dễ dàng để thêm khả năng kiểm tra tính hợp lệ của dữ liệu và các quy tắc vào trong mô hình dữ liệu của bạn.

Mô hình hóa CSDL dùng LINQ to SQL:

Visual Studio "Orcas" đã tích hợp thêm một trình thiết kế LINQ to SQL như một công cụ dễ dàng cho việc mô hình hóa một cách trực quan các CSDL dùng LINQ to SQL.  Bài viết sau sẽ đi sâu hơn vào cách dùng trình thiết kế này (bạn cũng có thể xem đoạn video này để xem cách tôi tạo một mô hình LINQ to SQL). 

Bằng cách dùng trình thiết kế LINQ to SQL, tôi có thể dễ dàng tạo một mô hình cho CSDL mẫu "Northwind" giống như dưới đây:

Mô hình LINQ to SQL ở trên định nghĩa bốn lớp thực thể: Product, Category, Order và OrderDetail. Các thuộc tính của mỗi lớp ánh xạ vào các cột của bảng tương ứng trong CSDL. Mỗi instance của một lớp biểu diễn một dòng trong bảng dữ liệu.

Các mũi tên giữa bốn lớp thực thể trên biểu diễn quan hệ giữa các thực thể khác nhau, chúng được tạo ra dựa trên các mối quan hệ primary-key/foreign-key trong CSDL. Hướng của mũi tên chỉ ra mối quan hệ là một - một hay một - nhiều. Các thuộc tính tương ứng sẽ được thêm vào các lớp thực thể trong các trường hợp này. Lấy ví dụ, lớp Category ở trên có một mối quan hệ một nhiều với lớp Product, điều này có nghĩa nó sẽ có một thuộc tính "Categories" là một tập hợp các đối tượng Product trong Category này. Lớp Product cũng sẽ có một thuộc tính "Category" chỉ đến đối tượng "Category" chứa Product này bên trong.

Bảng các phương thức bên tay phải  bên trong trình thiết kế LINQ to SQL ở trên chứa một danh sách các SP để tương tác với mô hình dữ liệu của chúng ta. Trong ví dụ trên tôi đã thêm một thủ tục có tên "GetProductsByCategory". Nó nhận vào một categoryID và trả về một chuỗi các Product. Chúng ta sẽ xem bằng cách nào có thể gọi được thủ tục này trong một đoạn code bên dưới.

Tìm hiểu lớp DataContext

Khi bạn bấm nút "Save" bên trong màn hình thiết kế LINQ to SQL, Visual Studio sẽ lưu các lớp .NET biểu diễn các thực thể và quan  hệ bên trong CSDL mà chúng ta vừa mô hình hóa. Cứ mỗi một file LINQ to SQL chúng ta thêm vào solution, một lớp DataContext sẽ được tạo ra, nó sẽ được dùng khi cần truy vấn hay cập nhật lại các thay đổi. Lớp DataContext được tạo sẽ có các thuộc tính để biểu diễn mối bảng được mô hình hóa từ CSDL, cũng như các phương thức cho mỗi SP mà chúng ta đã thêm vào.

Lấy ví dụ, dưới đây là lớp NorthwindDataContext được sinh ra dựa trên mô hình chúng ta tạo ra ở trên:

Các ví dụ LINQ to SQL

Một khi đã mô hình hóa CSDL dùng trình thiết kế LINQ to SQL, chúng ta có thể dễ dàng viết các đoạn lệnh để làm việc với nó. Dưới đây là một vài ví dụ về các thao tác chung khi xử lý dữ liệu:

1) Lấy các Product từ CSDL

Đoạn lệnh dưới đây dùng cú pháp LINQ để lấy về một tập IEnumerable các đối tượng Product. Các sản phẩm được lấy ra phải thuộc phân loại "Beverages":

C#:

VB:

2) Cập nhật một sản phẩm trong CSDL

Đoạn lệnh dưới đây cho thấy cách lấy một sản phẩm, cập nhật lại giá tiền và lưu lại CSDL.

C#:

VB:

3) Chèn thêm một phân loại mới và hai sản phẩm vào CSDL

Đoạn mã dưới đây biểu diễn cách tạo một phân loại mới, và tạo hai sản phẩm mới và đưa chúng vào trong phân loại đã tạo. Cả ba sau đó sẽ được đưa vào cơ sở dữ liệu.

Chú ý rằng tôi không cần phải tự quản lý các mối quan hệ primary key/foreign key, thay vào đó, tôi chỉ đơn giản thêm các đối tượng Product vào tập hợp Products của đối tượng category, và rồi thêm đối tượng category vào tập hợp Categories của DataContext, LINQ to SQL sẽ biết cách thiết lập các giá trị primary key/foreign key một cách thích hợp.

C#

VB:

4) Xóa các sản phẩm

Đoạn mã sau sẽ biểu diễn cách xóa tất cả các sản phẩm Toy khỏi CSDL:

C#:

VB:

5) Gọi một thủ tục

Đoạn mã dưới đây biểu diễn cách lấy các thực thể Product mà không dùng cú pháp của LINQ, mà gọi đến thủ tục "GetProductsByCategory" chúng ta đã thêm vào trước đây. Nhớ rằng một khi đã lấy về kết quả, tôi có thể cập nhật/xóa và sau đó gọi db.SubmitChanges() để cập nhật các thay đổi trở lại CSDL.

C#:

VB:

6) Lấy các sản phẩm và phân trang

Đoạn mã dưới đây biểu diễn cách phân trang trên server như một phần của câu truy vấn LINQ. Bằng cách dùng các toán tử Skip() và Take(), chúng ta sẽ chỉ trả về 10 dòng từ CSDL - bắt đầu từ dòng 200.

C#:

VB:

Tổng kết

LINQ to SQL cung cấp một cách hay, rõ ràng để mô hình hóa lớp dữ liệu trong ứng dụng của bạn. Một khi đã định nghĩa  mô hinh dữ liệu, bạn có thể dễ dàng thực hiện các câu truy vấn cũng như cập nhật, xóa, sửa dữ liệu một cách hiệu quả.

Hi vọng những hướng dẫn và ví dụ mẫu ở trên đã giúp bạn làm quen với LINQ. Tôi sẽ tiếp tục các bài viết này để giúp bạn khám phá LINQ to SQL một cách chi tiết hơn.

Thanks for Expression (under System.Linq.Expressions namespace), we can keep the expression tree but not compiled MSIL code.

When you use Linq like this,

[code language='csharp']

var count = from dataItem in data where dataItem.Value > 100 select data.Value2;

[/code]

You do not need to know the expression tree (You even do not need to add the using of System.Linq.Expressions), .NET compiler and runtime to all the things for you.

That good most of the times.

Sometimes, you need to do something by yourself. Just like my current project, I need get the result directly from a expression tree.

[code language='csharp']

object GetResult(Expression m);

T GetResult(Expression m);

[/code]

The only one I can find to do this directly is Excute method in IQueryProvider interface.

[code language='csharp']

public interface IQueryProvider
{
Object Excute(Expression expression);

TResult Excute
(Expression expression);
}

[/code]

Looks great, but useless. It use an interface, and I cannot find a impliment in the framework.

Ok, it's time to show you the truth. No more words. Just the code below.

[code language='csharp']

public static object GetResult(this Expression m)
{
if (m == null)
throw new ArgumentException("m");
Type type = typeof (Func<>).MakeGenericType(m.Type);
LambdaExpression lambda = Expression.Lambda(type, m);
Delegate callback = lambda.Compile();
object result = callback.DynamicInvoke();
return result;
}

public static T GetResult(this Expression m)
{
if (m == null)
throw new ArgumentNullException("m");
Expression> lambda = Expression.Lambda>(m);
Func callback = lambda.Compile();
T result = callback();
return result;
}

[/code]

Compile to MSIL at runtime, isn't it cool?!

public static class ListExtensions {
  public static IEnumerable<T> Randomise<T>(this IEnumerable<T> list) {
    Random rand = new Random();
    var result = list.OrderBy(l => rand.Next());
    return result;
  }
}

How does it work…? It adds the Randomise() extension method to the end of any IEnumerable<T> (e.g. List<T>) and uses the OrderBy function to change the sort order based on a randomly generated number.

var randomCategories = context.Categories.Randomise();

The above code will execute the Randomise function to reorder the list of Category objects retrieved from the context randomly and assign the result to randomCategories.

So I wrote a simple VS 2008 plug-in which allow with 2 clics a synchronization between my database and My DBML Schema.

Here the installer :

Linq To SQL Synchronizer

Rename the .ppt file in .zip file.

After installing, the add-in file must be define in userProfile/documents/VS2008/Addins/ folder and the assembly, for example, in program files folder.

If problems comes, be sure to check the path of the assembly in the .addin file(userProfile). It must reference the assembly in the program files(in this case).

The add-in is too simple that I haven't done a User Guide. I let you eval :-)

XDocument xdoc = new Xdocument(...)
SchemaSet schemaSet = new XmlSchemaSet();
schemaSet.Add(null, "filename.xsd");

Once you have a xdocument object and a schemaset object you call the Validate method of the xdocument objecct:

xdoc.Validate(schemaSet, null);

Ülesanne

Kujutagem ette olukorda, kus näiteks ListBoxi sisuks on mingi järjendi sisu:

<ListBox x:Name="listBox" />

List<string> nimed = new List<string>();
nimed.Add("Jaana");
nimed.Add("Indrek");
nimed.Add("Ilse");
nimed.Add("Jaan");

listBox.ItemsSource = nimed;

nimed.Add("Lotte");

See annab tulemuseks:

Siin ei ole aga elementi Lotte, mis sai lisatud peale listBoxi sidumist nimede järjendiga.

Üks lahendus oleks igal korral, kui andmestikku muudame, listBox ära nullida:

nimed.Add("Lotte");
listBox.ItemsSource = null;
listBox.ItemsSource = nimed;

Suhteliselt ebamugav aga ajab asja ära - nüüd jõuab Lotte ka nimekirja.

On olemas aga palju lihtsam viis – kasutada tavalise Listi asemel ObservableCollection-it, mis annab oma muudatustest automaatselt teada kõigile, kellega ta seotud on. Hetke näites, uueneb automaatselt listBoxi sisu. Ainus vajalik muudatus eelnevates koodilõikudes (ListBoxi nullima enam ei pea):

ObservableCollection<string> nimed = new ObservableCollection<string>();

Samm edasi

Aga olgu meil nüüd nii, et ListBoxis on ainult osad nimed, näiteks sellised, mis vastavad mingile kindlale LINQ lausele.

Lisame näitele TextBoxi, mille abil filtreerime nimekirjast teatud nimed välja:

<TextBox x:Name="_filterTextBox"/>

ListBoxi andmeallikaks saab nüüd järgnev LINQ päring:

listBox.ItemsSource = from nimi in nimed
                      where nimi.StartsWith(_filterTextBox.Text)
                      select nimi;

Mõte on ju hea aga see ei tööta. Tekib kaks probleemi:

1. Kuigi nimed on ikka veel ObservableCollection-is, siis elementi Lotte listboxis ei ole (Lotte on lisatud pärast listBox.ItemsSource = … rida)
2. Kui midagi tekstikasti trükkida, siis ei toimu filtreerimist.

Üks lahendus:

Jätta esialgu ikkagi listBox.ItemsSource = nimed ning lisada tekstikastile sündmusekuular:

<TextBox x:Name="_filterTextBox" TextChanged="_filterTextBox_TextChanged"/>

Ja iga kord, kui see sündmus tekib muuta listBoxi andmeallikat:

private void _filterTextBox_TextChanged(object sender, TextChangedEventArgs e){    listBox.ItemsSource = from nimi in nimed                          where nimi.StartsWith(_filterTextBox.Text)
                          select nimi;}

Töötab, aga tegelikult on üks lahendus veel …

Bindable LINQ

Bindable LINQ is a set of extensions to LINQ that add data binding and change propagation capabilities to standard LINQ queries.

Ehk BIndable LINQ teeb LINQ päringud muudatustetundlikuks, ta saab aru, kui LINQ lause sõltub mingitest kolmandatest muutuvatest parameetritest. Siinses näites siis faktid, et nimede järjend võib muutuda ja et tekstikastist tulev tekst muutub. Bindable LINQ võtab kõike seda arvesse ning lahendab meie ülesande elegantselt:

listBox.ItemsSource = from nimi in nimed.AsBindable()
                      where nimi.StartsWith(FilterTextBox.Text)
                      select nimi;

See AsBindable() tulebki BinableLinq-st, mille saab tõmmata siit. Kasutamiseks tuleb see lisada projekti: Project->Add Reference->Browse sinna, kus on BindableLINQ.dll, samuti tuleb lisada using Bindable.Linq;

Kogu kood:

Page.xaml

<UserControl x:Class="Bindable.Page"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Width="400" Height="300">
    <Grid x:Name="LayoutRoot" Background="White">
        <Grid.RowDefinitions>
            <RowDefinition Height="40"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>
            <TextBox x:Name="_filterTextBox" Grid.Row="0" />
            <ListBox x:Name="listBox" Grid.Row="1"/>
    </Grid>
</UserControl>

Page.xaml.cs

using System.Collections.ObjectModel;
using System.Windows.Controls;
using Bindable.Linq;

namespace Bindable
{
    public partial class Page : UserControl
    {
        private ObservableCollection<string> nimed;

        public Page()
        {
            InitializeComponent();
            Loaded += new System.Windows.RoutedEventHandler(Page_Loaded);
        }

        void Page_Loaded(object sender, System.Windows.RoutedEventArgs e)
        {
            nimed = new ObservableCollection<string>();
            nimed.Add("Jaana");
            nimed.Add("Indrek");
            nimed.Add("Ilse");
            nimed.Add("Jaan");

            listBox.ItemsSource = from nimi in nimed.AsBindable()
                                  where nimi.StartsWith(FilterTextBox.Text)
                                  select nimi;

            nimed.Add("Lotte");
        }

        public TextBox FilterTextBox
        {
            get { return _filterTextBox; }
        }
    }
}

Tähele tuleks panna kõige viimast meetodit – nimelt peab _filterTextBoxi avalikuks tegema, muidu Bindable LINQ tema väärtust kätte ei saa.

Tulemus:

Testi (Silverlight 2 RC 0)

Lae alla (zip)

Lõppsõna

Binable LINQ on lahe ning veel lahedam oleks, kui ta saaks päris LINQ loomulikuks osaks :).

And I have to say that I'm fairly pleased with the result, it's only a handful of code (less than 100 LoC) but it makes testing so much easier.

I'm so pleased with it that we will be using this in a fairly large live project, a large portion of every Swedish citizens that turn 18 will pass through this system :-)

It has enabled us to test all of our service methods with in mem data w/o ever changing,faking or mocking our repositories.

So cheers to both Erik Meijer for making Linq such a cool tool and to Jimmy Nilsson for inventing the workspace pattern :-)

Michael organised to come over to my place after work on Thursday night so we can bounce a bunch of ideas of each other and then spend the night, I then organised for the both of us to take Friday off work so that we could focus on this a little more without those pesky work distractions :)

I think by the end of the day (well COB) we should have the better part of the application complete, or at least I hope that's the case!

I don't want to mention too much of what I've done as I think it will kind f give our app away, even though Michael has listed the three major technologies I'm using on his blog (damn you Mike) so no real technology updates.

What I learnt yesterday was that LINQ is supported on mobile devices, I'll never cease to be amazed at the .Net framework, good job CF team!  It's funny coming in to this I thought we were going to have to write a lot of stuff ourselves - I figured the Compact Framework was just going to be a really crippled / cut  down version of the regular framework and don't get me wrong - there are some things missing (GDI+ for one!) but 90% of the functionality I've needed has been there and I thought it was going to be a lot closer to say 50%, I'm pleasantly surprised.

Anyway got to run, got to get some code done whilst Michael is still asleep :)

Có rất nhiều thứ miễn phí dành cho bạn:
- Công cụ miễn phí
- Dịch vụ host miễn phí trên Popfly
- Các bài hướng dẫn từ BDLC
- Các control và ebook
- Các đoạn code mẫu trong Coding4Fun Development Kit
- Bộ công cụ P2P, và
- Bộ công cụ C++ Game Development

2. LINQ và các cải tiến ngôn ngữ

Visual Studio Express 2008 hỗ trợ đầy đủ LINQ (Language INtergrated Query) cho phép việc thực hiện ngôn ngữ truy vấn (tương tự như SQL) trực tiếp trong ngôn ngữ Visual Basic và C#. Điều này có nghĩa là bạn có thể truy vấn một cơ sở dữ liệu dạng XML chẳng hạn như các RSS feeds hay các đối tượng bên trong bộ nhớ bằng cách sử dụng một cú pháp đơn giản. Đi cùng với LINQ là một số những cải tiến trong ngôn ngữ giúp đơn giản hoá công việc với các kiểu dữ liệu của .NET và điều này sẽ được thấy rõ khi ta làm việc với LINQ.

3. Nhiều nội dung học miễn phí

Beginner Developer Learning Center (BDLC) có các đoạn video cho 4 sản phẩm của Express Edition cũng như các bài tutorial về LINQ, WPF,...

4. Bộ thiết kế web và công cụ Javascript mới

Được xây dựng dựa trên các engine của Expression Web, Visual Web Developer Express designer bao gồm một design view mạnh với các tính năng mới như Split View để xem cả HTML code và designer, cửa sổ CSS Styles và Properties để thiết kế, xem trước, và apply các kiểu khác nhau.
Công cụ Javascript có cải tiến hơn về Intellisense, suy luận kiểu dữ liệu, IntelliSense tham số, hỗ trợ các Ajax control, bộ debug được cải tiến với visualizers cho các dữ liệu của Javascript,...

5. Windows Presentation Foundation

Một điểm mới trong Visual Basic và Visual C# 2008 Express Edition là một bộ designer trực quan và các template project để xây dựng các ứng dụng WPF. Bạn có thể xây dựng các ứng dụng đẹp, có khả năng tương tác sử dụng các media, animation và đồ hoạ 2D/3D với WPF. Hơn nữa, bạn có thể sử dụng các control WPF trong các ứng dụng Windows Form. Do đó bạn có thể tạo ra các control nặng về mặt đồ hoạ, giao diện trong WPF và sau đó gắn chúng vào ứng dụng Windows Form của mình.

6. Bộ công cụ phát triển Game cho C++

7. Hỗ trợ ASP.NET AJAX và các Ajax Control

Trong Visual Web Developer Express 2008 có sẵn ASP.NET AJAX giúp bạn có thể dễ dàng thực hiện công việc cập nhật partial-page (cập nhật bằng cách nhận dữ liệu động từ server mà không cần phải load lại trang) chỉ với 1 thao tác là add control UpdatePanel vào. Hơn nữa, bạn có thể sử dụng lại tất cả bộ ASP.NET AJAX Control Toolkit để trang web có các tính năng RAD AJAX như animation, đổ bóng (drop shadows), góc bo tròn (rounded corner),...

8. Nâng cao hiệu suất hoạt động

Trong phiên bản này nhóm phát triển đã cố gắng tăng hiệu suất hoạt động cho các công việc như Visual Basic background compiler hay C# IntelliSense. Bạn sẽ cảm nhận sự khác biệt khi phát triển các dự án lớn.

9. Killer Content

Bộ Coding4Fun Developer Toolkit cung cấp nhiều sample và resource hỗ trợ Windows Vista như Telephony, Mail, Calendar,...

10. Những "đồ chơi" miễn phí

Khi bạn register bộ Visual Studio Express, bạn sẽ nhận được
- Các control miễn phí như Telerik Rad Ribbon Bar để xây dựng các ứng dụng có giao diện Office 2007,...
- Các hình ảnh, icon miễn phí
- Ebook miễn phí
- Giảm giá
Sau khi đăng ký xong hãy đến trang http://connect.microsoft.com để download

(nguồn : http://ciren.vn/forums/showpost.php?p=2756&postcount=5)

I've even gone so far as to call the same method three different ways to show how easy it is to go from 'traditional' code design to C#'s new functional format using lambda opterators. For those of you who are fluent in JavasScript, this should feel fairly normal.

   1:  class Program {

   2:          static void Main( string[ ] args ) {

   3:              Func<int, long> factorial = ( int num ) => {

   4:                  long value = 1;

   5:                  for ( int i = 1 ; i <= num ; i++ ) {

   6:                      value *= i;

   7:                  }

   8:                  return value;

   9:              };

  10:   

  11:              for ( int i = 10 ; i > 0 ; i-- ) {

  12:                  Console.WriteLine("A: {0} factorial is {1}", i, factorial(i));

  13:                  (new Runner<int, long>('B')).Do(( int num ) => { long value = 1; for ( int f = 1 ; f <= num ; f++ ) value *= f; return value; }, i, ( char id, int initial, long final ) => { Console.WriteLine("{0}: {1} factorial is {2}", id, initial, final); });

  14:                  (new Runner<int, long>('D')).Do(factorial, i, ( char id, int initial, long final ) => { Console.WriteLine("{0}: {1} factorial is {2}", id, initial, final); });

  15:                  (new Runner<int, long>('E')).Do(factorial, i, CallbackTo);

  16:              }

  17:   

  18:              Console.Read();

  19:          }

  20:   

  21:          static void CallbackTo( char id, int initial, long final ) {

  22:              Console.WriteLine("{0}: {1} factorial is {2}", id, initial, final);

  23:          }

  24:      }

  25:   

  26:      public class Runner<T, R> {

  27:          private Func<T, R> worker;

  28:          private T initial;

  29:          private char id;

  30:   

  31:          public Runner( char id ) {

  32:              this.id = id;

  33:          }

  34:   

  35:          public void Do( Func<T, R> worker, T value, Callback callback ) {

  36:              this.worker = worker;

  37:              this.initial = value;

  38:              Thread thread = new Thread(new ThreadStart(( ) => {

  39:                  R final = worker(value);

  40:                  callback(id, initial, final);

  41:              }));

  42:              thread.Start();

  43:          }

  44:   

  45:          public delegate void Callback( char id, T intial, R final );

  46:      }

As you can see, I use generics to define a worker function and then use a generic class to do fire off a thread that'll call back to the main thread when it's complete. Fairly straight foreward. I even threw in a standard call to a "normal" synchoronous method call for comparison.

The output from the test looks like this:
 

A: 5 factorial is 120
A: 10 factorial is 3628800
B: 10 factorial is 3628800
C: 10 factorial is 3628800
D: 10 factorial is 3628800
A: 9 factorial is 362880
E: 10 factorial is 3628800
B: 9 factorial is 362880
C: 9 factorial is 362880
D: 9 factorial is 362880
A: 8 factorial is 40320
E: 9 factorial is 362880
B: 8 factorial is 40320
C: 8 factorial is 40320
D: 8 factorial is 40320
A: 7 factorial is 5040
B: 7 factorial is 5040
E: 8 factorial is 40320
C: 7 factorial is 5040
D: 7 factorial is 5040
A: 6 factorial is 720
E: 7 factorial is 5040
B: 6 factorial is 720
C: 6 factorial is 720
D: 6 factorial is 720
A: 5 factorial is 120
E: 6 factorial is 720
B: 5 factorial is 120
C: 5 factorial is 120
D: 5 factorial is 120
A: 4 factorial is 24
E: 5 factorial is 120
B: 4 factorial is 24
C: 4 factorial is 24
D: 4 factorial is 24
A: 3 factorial is 6
E: 4 factorial is 24
B: 3 factorial is 6
C: 3 factorial is 6
D: 3 factorial is 6
A: 2 factorial is 2
E: 3 factorial is 6
B: 2 factorial is 2
C: 2 factorial is 2
D: 2 factorial is 2
A: 1 factorial is 1
E: 2 factorial is 2
B: 1 factorial is 1
C: 1 factorial is 1
D: 1 factorial is 1
E: 1 factorial is 1

1. Write to XML
2. Read from XML.

Write to XML

The logic behind writing to XML for the guest book is

1. We have to check whether the desired XML is exists or not.
2. If it exists, that means this is not the first time entry. We have to append entries with the previous entry.
3. If it does not exist, that means the first guest is writing to the guest book. We have to create the XML and write to it.

let's consider the xml as "FeedbackList.xml" and we are going to put it in our C drive. To start lets make a web form with 4 textboxes. Those are txtName, txtEmail, txtCountry and txtMsg. And to see how the xml looks like lets take another multiline textbox into which we will display the resultant xml. Obviously you are not going to put this into your  final guest book. At this moment your page should look like below.

Now at the button click event write the following code.

In the above code, system first checks whether the "FeedbackList.xml" exists in the C drive or not. If exixts, system adds one by one name, email, country and messages from the corresponding text boxes.

Finally, system displays the resultant xml into the txtOut text box and saves the original xml. Now lets have a look into the else block.

In the above code, system fails to find the desired xml and that means this is first time any guest is writing message. So we are not going to use FeedbackList. Add this time. We will simply create new XElement, put data from the textboxes and save.

That is all. Run it and try to enter something and you will see some excellent output. Don't forget to include using System.XML.LINQ at the top.

Read from XML

Now its time to read from the FeedbackList.xml into a nice Grid using the gridview control.

Let's make another webform and name it GuestBookData.aspx. Add a gridview control in it. Go to the code behind page and write the following code.

in the above code, system first loads the FeedbackList.xml from C drive. Then using LINQ we are fetching the values of every element and finally bind it to gridview. Run the page and you will something like this;

That's all. Isn't it cool and easy.

Happy coding mate.

cheers

You can find the code for the function here. For example, within a static class called Enumerable2, you can call it as such:

var combinedList = Enumerable2.CombineOrdered(listA, listB, keySelector);

Note: The given implementation needs to take lists sorted in an ascending order and returns a combined list in the same order. To sort descending, change the <= sign to a >= sign in the code and insure that you pass lists sorted in a descending order.

Steve Michelotti describes how to do it here:

http://geekswithblogs.net/michelotti/archive/2007/12/17/117791.aspx

and if your entity has child objects check this post out:

http://geekswithblogs.net/michelotti/archive/2007/12/30/118076.aspx

So, getting your objects from your .NET 3.5 Linq to SQL setup to Flex is fairly easy. Getting the changed data back and synchronised to your DB is a different story.

The great thing about LINQ is that the data you retrieve and modify in .NET will automatically sync back to the DB by calling the SubmitChanges() method on your context (Linq to SQL) object.

The problem is of course when this data comes back in from Flex, the system doesn't know what exactly has changed.

Now, the first thing to realise is that your Value Objects in Flex should NOT have the foreign key IDs in them. Why? Because say in the Company/Employee example, if you submit a Company object back to the system, with each Employee in the list having both a CompanyID AND a Company object reference, how will the LINQ system know which is the correct reference?

These foreign IDs will try to get serialised on the remoting level and be ignored. Good. We're dealing with object references now, and foreign key ids are useless. If I want the foreign key of some employee, I would say: EmployeeObj.Company.CompanyID

Now, in .NET, I have a "Save()" method that I want to essentially insert/update the object and all objects within in.

Using the example before, say I have a company object, and that has a list of Employees. Then if I have a Save(Company c) method, I want the company object to insert/update, and the list of employees to automatically synchronise.

You can try deleting the old object and then inserting the new

So,

SaveCompany(Company newCompany)
{

DataClassesDataContext db = new DataClassesDataContext();
if (newCompany.CompanyID > 0)
{

Company oldCompany = db.Companies.Single<Company>(c => c.CompanyID = newCompany.CompanyID);
db.Companies.DeleteOnSubmit(oldCompany);
}
db.Companies.InsertOnSubmit(newCompany);
db.SubmitChanges();
}

This will nicely handle an insert/update of the company object, but it won't deal with your Employee objects that well. Especially when each Employee references anthor table that essentially depicts there type./

Say each Employee has a foreign key reference to EmployeeType. Employee type is a static naming table that has a set of 5 records: "Manager", "Sales Coordinator", "Receptionist", "Consultant" and "Helpdesk". Then my Employee object will have an EmployeeType property (loaded via LINQ). Now, when this goes through LINQ, I believe during the serialisation, the creation of a "new" object EmployeeType will mean that the code above will create a new EmployeeType record for the Employee. Ouch.

So even though you may have sent all the employees through LINQ to Flex via a Company object, when it comes back, even if unchanged, all these employees will have references to new EmployeeType objects.

The way to solve this is fairly easy:

foreach (Employee e in newCompany.Employees)
{
   EmployeeType type = db.EmployeeType.Single<EmployeeType>(t => t.TypeID == e.EmployeeType.TypeID);
   e.EmployeeType = type;
}

oldCompany.Employees = newCompany.Employees;

Unfortunately, it's not an easy process to learn how exactly to handle each scenario in synching LINQ and Flex, but one thing's for sure, it certainly makes code lighter, and a lot easier to update.

As I mentioned in the previous post, with Insert, Update and Delete methods but without a Select method, LinqDataSource control looks just like a chair with only three legs! Specially when it comes to situations that you have to retrieve records programatically.

I probed alot to see if there is a work around for this problem but found nothing. Therefore I wrote my own LinqDataSource that supports this fearure. I called this control GoodLinqDataSoruce !  GoodLinqDataSource contains a method called SelectRecords which returns a non-generic IEnumerable. Selecting event event is triggered before the record retrieval is perforemd and afterwards Selected event is fired.

How this control is implemented?

LinqDataSource contains a protected method called GetView(string viewname) which returns a DataSourceView object. Infact, the retrieval actions is taken place with DataSourceView class. Moreover, LinqDataSource uses an extended version of DataSourceView named LinqDataSourceView . LinqDataSourceView has a Select method that performs record retrival and returns the result as an IEnumerable.

Since the source code is straighforward, I will bring it here :

public class GoodLinqDataSource : LinqDataSource

{

private LinqDataSourceView DefaultView

{