Core ASP.NET

Download
FREE PDF

The Essential ASP.NET Cheat Sheet

DZone greatly appreciates your support.


Your download should begin immediately.
If it doesn't, click here.

People who downloaded this DZone Refcard also liked:

Getting Started with Visual Studio 2010

By Alessandro Del Sole

INTRODUCTION

The new version of the Visual Studio 2010 Integrated Development Environment ships with a number of new important features. Such features are both related to the IDE architecture and to the coding experience, with the addition of new tools as well. This Refcard is a quick reference to the most important new features and instruments in Visual Studio 2010, also providing tips to most common shortcuts.

STARTING WITH VISUAL STUDIO 2010

Visual Studio 2010 is the developer tool used for creating .NET applications. There are different editions which cover every need, such as the Ultimate edition or the free Express editions (the latter are specific for hobbyists and students).

Starting the IDE

When you run Visual Studio 2010, the first thing you notice is a new Start Page which provides shortcuts, organized into tabs, to lots of learning resources about programming different Microsoft technologies with Visual Studio. These include the .NET Framework and programming languages, data platform, cloud computing or tools for teams. The following figure shows how the Start Page looks:

Visual Studio 2010 offers a convenient way for managing the most recently used projects by simply right-clicking each project name in the list. With this action you can pin or remove items from the list itself.

Creating applications

You create .NET applications in Visual Studio 2010 by first creating projects. A project is the place where all the parts composing your application, such as code, libraries, dialogs, pages and resources, reside. An application can be composed of one or more projects. Multiple projects bound together are combined into a Solution. Thus, the first step is creating a new project. You accomplish this by selecting the New|Project command from the File menu. This will show the New Project dialog which looks like this:

As you can see, there are a number of available project types, grouped by programming language or by typology. As you can see from the above figure, the programming language project types are sub-grouped by technology. Once you have selected the desired project type, just assign a name and click OK. The Visual Studio documentation that ships with the product provides full descriptions for both Windows and Web projects.

In Visual Studio 2010 you can also target different versions of the .NET Framework (as shown in the figure above) or search specific project templates using the Search Installed Templates search box.

Building and debugging applications

You can build and run your executable application by pressing F5. This is common to both Windows and Web applications and will run your application with an instance of the Visual Studio debugger attached. Visual Studio provides a lot of debugging tools available in the Debug menu. For example, you can place breakpoints (also by pressing F9) or check for the value of local variables via the Locals tool window. If you don’t want to run the application under the debugger investigation, simply press Shift+F5.

You can quickly deploy your application using the ClickOnce technology, which you access via the Build|Publish command.

Browsing the documentation

You can access the Visual Studio documentation in different situations by pressing F1. For example you can get general information by pressing F1 anywhere or get specific help for an element in your code by selecting the code element (such as the name of a type) and, again, press F1. In Visual Studio 2010 the help system has been rebuilt completely and now allows you to browse the documentation inside your Web browser. The following figure shows an example:

WPF-BASED CODE EDITOR

Most of the Visual Studio 2010 architecture now relies on Windows Presentation Foundation, the most recent technology from Microsoft for building rich client applications. If you are an existing Visual Studio developer this is something you immediately notice when running the IDE for the first time; it affects a number of areas such as the Start Page and tabbed dialogs or tool windows. The code editor is also built upon WPF which provides some great benefits, including:

• Better text r endering
• Code editor zoom by pr essing CTRL + mouse wheel
• Automatic selection of all occurr ences of a word
• Tabbed code dialogs can be undocked and tr eated like any other window outside the IDE
• Improved extensibility: the code editor also takes advantage of MEF (Managed Extensibility Framework) to receive pluggable components. This allows hosting rich content inside the code editor, such as images, videos, WPF controls, comment adornments and so on.
• Reusability: you can reuse the code editor as a component in your own Visual Studio add-ins.

You interact with the code editor via the IWPFTextView interface which is described in the MSDN Library. The following image shows how the WPF-based code editor looks:

Notice that the zoom percentage is greater than 100%. This was accomplished simply by pressing CTRL + mouse wheel. A good number of code editor extensions are available in the Visual Studio Gallery Web site.

“GENERATE FROM USAGE” TOOL

In its continuous evolution, the Visual Studio environment has committed to offer even more sophisticated tools for helping developers write code. IntelliSense®, syntax highlighting, and auto-completion are just a few examples. It previously lacked the ability to create new objects on the fly. With Visual Studio 2010 you can now create new objects while writing code. This is useful when you realize that you need an object that you did not consider before or that you need to extend an existing object with new members. This functionality is integrated into the code editor and is known as Generate From Usage; it is available for both Visual Basic and C#.

Creating new types on the fly

Let’s start describing Generate From Usage by creating a new Console application. Consider the following situation, in which the code attempts to create an instance of the Contact class that actually does not exist yet and pay attention to the error correction options provided by the IDE:

Click Generate ‘Class Contact’ and Solution Explorer you will notice the presence of a file named Contact.vb (or .cs in C#) which contains the empty definition of the new class.

Now you can populate your class with new members, like in the following figure, where the code attempts to assign a non-inexistent property, but the IDE provides the possibility of generating a property or a field:

If you select the first option, Visual Studio will add a property named LastName of type String to the Contact class. Similarly you can add both instances and shared methods on the fly. It is worth mentioning that Visual Studio:

• generates members of the appropriate type when possible.
• is able to generate interfaces and methods referring to delegates according to the current scenario. When generating such methods, it is able to add the appropriate signature.

You saw how to create a class, which is the default type, and members with default visibility. But you can do more with Generate From Usage as explained in next subsection.

Creating different kinds of types

There are situations in which you need to create different kinds of objects, such as structures or enumerations. Generate From Usage makes this task easy. For example, you might want to create a new structure. If you type the following line of code:

Dim someData As New CustomData

the IDE marks CustomData as non-existent. From the error correction suggestions popup, simply select Generate New Type. This will prompt you with the Generate New Type dialog shown in the next figure:

Here you can:

• Provide the new object’s visibility by setting the Access property
• Decide what kind of object you want to cr eate from the Kind property
• Add the new member to a dif ferent project in your solution via the Project combo box
• Create a new code file or add the new object to an existing code file inside the File Name box

Simply click OK when you are done and the new object will be added to your solution according to the specified settings. At this point you can add new members as described in the previous section.

WPF & SILVERLIGHT: DRAG AND DROP DATA-BINDING

Visual Studio 2010 introduces an important feature for data development to both WPF and Silverlight: drag and drop data-binding. This technique has been very popular in the past among Windows Forms developers since it allows creating data forms quickly and easily. In order to make the data development experience easier in modern client technologies, such a technique is now available for WPF and Silverlight. In WPF full support is offered for DataSets and ADO.NET Entity Framework. With full support we intend complete UI and codebehind code generation. Support is also offered for custom business objects or different data sources such as LINQ to SQL or WCF Data Services, but only on the UI side, meaning that you need to write all the data access code from scratch. In Silverlight you don’t have DataSets, so you can use this kind of data-binding with Entity Framework and custom objects.

Creating the data-bound interface

Whatever your data source is, you may open the Data Sources window and then simply drag your desired data item from the window onto the designer surface, as it was done previously in Windows Forms applications. The following figure provides an example based on the Entity Framework as the data source:

As in older technologies, you can still create grid views or details views and you are allowed to replace the default controls with different ones. You can drag an entire object to create a view or a single object onto an items container control such as the ListBox for creating lists.

Dragging and dropping the data is just the first step since you obviously need some code.

A tour of the code

When you use the drag and drop binding, Visual Studio generates some useful code for you. This not only refers to the user interface and controls, but also to querying data. On the XAML side, it first generates the appropriate CollectionViewSource objects acting like “bridges” between data and UI:

<Window.Resources>
	  <CollectionViewSource x:Key=”CategoriesViewSource” d:DesignSo
urce=”{d:DesignInstance my:Category, CreateList=True}” />
	  <CollectionViewSource x:Key=”CategoriesProductsViewSo
urce” Source=”{Binding Path=Products, Source={StaticResource
CategoriesViewSource}}” />
	</Window.Resources>

Next it generates data-bound controls, such as a DataGrid and Label/TextBox couples if considering the previous image (notice the Binding markup extension pointing to the bound property):

<DataGrid AutoGenerateColumns=”False” EnableRowVirtualization=”True”
Height=”128” HorizontalAlignment=”Left” ItemsSource=”{Binding}”
Name=”CategoriesDataGrid” RowDetailsVisibilityMode=”VisibleWhenSelect
ed” VerticalAlignment=”Top” Width=”248”>
	<DataGrid.Columns>
		<DataGridTextColumn x:Name=”CategoryIDColumn”
Binding=”{Binding Path=CategoryID}” Header=”Category ID”
Width=”SizeToHeader” />
		<DataGridTextColumn x:Name=”CategoryNameColumn”
Binding=”{Binding Path=CategoryName}” Header=”Category Name”
Width=”SizeToHeader” />
		<DataGridTextColumn x:Name=”DescriptionColumn”
Binding=”{Binding Path=Description}” Header=”Description”
Width=”SizeToHeader” />
	</DataGrid.Columns>
  </DataGrid>
…
	<Label Content=”Product ID:” Grid.Column=”0” Grid.Row=”0”
HorizontalAlignment=”Left” Margin=”3” VerticalAlignment=”Center” />
	<TextBox Grid.Column=”1” Grid.Row=”0” Height=”23”
HorizontalAlignment=”Left” Margin=”3” Name=”ProductIDTextBox”
Text=”{Binding Path=ProductID, Mode=TwoWay,
ValidatesOnExceptions=true, NotifyOnValidationError=true}”
VerticalAlignment=”Center” Width=”100” />
…

It is worth mentioning that Visual Studio also maps data types to the appropriate controls. A typical example is when you have data of type System.DateTime that is represented via a DatePicker control (available in .NET 4 only). On the managed code side, Visual Studio generates some starting code for querying data. In case you use the Entity Framework as the Data Access Layer, the generated code looks like this (continuing the example from the previous image):

Class MainWindow
	Private Function GetCategoriesQuery(ByVal NorthwindEntities As _
										WpfApplication1.
NorthwindEntities) _
										As System.Data.Objects.
ObjectQuery(Of WpfApplication1.Category)

	Dim CategoriesQuery As System.Data.Objects.ObjectQuery(Of
WpfApplication1.Category) =
		   NorthwindEntities.Categories
		‘Update the query to include Products data in Categories. You
can modify this code as needed.
		CategoriesQuery = CategoriesQuery.Include(“Products”)
		‘Returns an ObjectQuery.
		Return CategoriesQuery
	End Function
	
	Private Sub Window_Loaded(ByVal sender As System.Object,
							  ByVal e As System.Windows.
RoutedEventArgs) _
							  Handles MyBase.Loaded
		Dim NorthwindEntities As WpfApplication1.NorthwindEntities =
			New WpfApplication1.NorthwindEntities()
		‘Load data into Categories. You can modify this code as
needed.
		Dim CategoriesViewSource As System.Windows.Data.
CollectionViewSource =
			CType(Me.FindResource(“CategoriesViewSource”), System.
Windows.Data.CollectionViewSource)
		Dim CategoriesQuery As System.Data.Objects.ObjectQuery(Of
WpfApplication1.Category) =
		  Me.GetCategoriesQuery(NorthwindEntities)
		CategoriesViewSource.Source = CategoriesQuery.
									  Execute(System.Data.Objects.
MergeOption.AppendOnly)
   End Sub
End Class

This will allow loading some data when you run the application. Once you have your starting code, you can write your own queries or extend the auto-generated code with additional features, such as Insert/Update/Delete operations or provide data navigation functionalities.

WPF & SILVERLIGHT: MULTI-TARGETING DESIGNER

In previous versions of Visual Studio the design-time experience for WPF and Silverlight developers did not offer specialized design tools. For WPF developers, the IDE lacked some tooling familiar to Windows Forms developers. Visual Studio 2008 introduced some improvements to the WPF design experience, like the ability to drag controls from the toolbox and drop them onto the designer surface, or the possibility to access event handlers by double-clicking the controls. But no support was available for setting special properties inside the Properties Window (e.g. brushes) so developers needed to manually write the code to set them. For Silverlight developers, things were even worse, in that you had neither drag and drop support nor design time support such as adjusting the application layout, so everything had to be set in code. Although Visual Studio is a developer tool, Microsoft Expression Blend is the tool best suited for deep customization of the user interface. While lots of developers use only Visual Studio to create the user interface for their applications, the need for better VS designer program was paramount. This is what happened with the release of Visual Studio 2010. In the next section you get an overview of the new and improved features, while later you will get information about how this targets multiple .NET Framework versions.

Improved experience

With Visual Studio 2010, both the WPF and Silverlight esigners now provide a full design-time experience and, most importantly, both technologies share the same tools. This means that you have the same instrumentation available for both WPF and Silverlight projects. You now have full support for dragging and dropping controls from the toolbox, for rearranging controls on the controls’ surface and you can also set complex properties within the Properties Window. The following figure represents such a description with regard to a WPF project:

If you try to do this inside a Silverlight project, you get exactly the same result and tools available. Notice how you now have a new color picker editor available for properties of type brush, which allows specifying the brush color, its type (e.g. a gradient or an image) and manually entering the color code. Prior to Visual Studio 2010 this had to be performed by writing pure XAML code. There are a number of other improvements in this area that are listed below.

Setting grid columns and rows

You can easily set rows and columns within a Grid control by selecting the RowDefinitions and ColumnDefinitions properties in the Property Window and then by taking advantage of a new dialog that looks like the following figure:

You simply click Add, then set properties for each row or column, such as the Height or Width.

Searching for a property

The Properties Window has been enhanced with a number of new features. You got a taste of this in the previous section when discussing how to set properties of type Brush. Another interesting addition is that you can now search for a specified property by writing its name in the search box at the top of the window. Also, you do not need to write the entire property name since Visual Studio filters the property list as you type characters inside the search box:

This way you can easily reach and set the properties you want to assign.

Setting controls’ fonts

In Visual Studio 2010 you can now easily set font properties to controls supporting fonts via an integrated tool inside the Properties Window.

For instance, you can select the font from a combo box and then set text alignment, size and weight all together, as shown in the following figure:

Visually setting data-binding and resources

The Properties Window also improves the way you assign data-bound properties or resources. You select the data-bound property for your control and then you can easily use the Binding popup as follows:

1. Select your data source. This can be the DataContext—another control or a resource as shown in the followingfigure:

   

2. Switch to the Path tab in order to select the property you wish to be bound;
3. Select any value converter you want to apply via the Converter tab; and
4. Finally go to the Options tab and apply any other additional options. This is really impressive in that you have a great number of available properties such as data error validation or triggering property changes.

You can apply resources similarly. For example, if you defined a style for a button and then you want to apply such a style, just right click the Style property in the Properties Window and select Apply Resource. This will provide a useful popup where you will be able to pick both default and local resources, as demonstrated in the following figure:

You can also choose between static and dynamic resources and you are offered a preview of the result you get once the resource is applied.

Multiple .NET Framework versions targeted

Visual Studio 2010 ships with integrated support for Silverlight 3 but it also supports Silverlight 4 when you install the appropriate developer tools. The good news is that all the stuff you have seen so far, including the drag and drop databinding, is available for both .NET Framework 3.5 SP 1 and 4.0 in Visual Studio 2010. This is what is usually referred to as multi-targeting, when talking about the designer. This basically means that you can create applications for WPF 3.5, WPF 4, Silverlight 3 and 4 taking advantage of all the new designer features independent of the technology or its version. If you want to check this out by yourself, simply create a new WPF or Silverlight project and in the New Project dialog select the .NET Framework 3.5 as the target Framework. You will notice no difference in the designer if compared to .NET 4.

COMMON SHORTCUTS AND TIPS

Visual Studio 2010 offers both shortcuts for quick access to common tools and instruments that you may find really useful. This section provides information on both topics.

Common shortcuts

• Start the application in debugging mode by pr essing F5 or without attaching the debugger by pressing Shift+F5
• Save all files in your solution by pr essing Ctrl+Shift+S
• Build your solution by pr essing Ctrl+Shift+B
• Run your application without the debugger by pr essing Shift+F5
• Show the toolbox by pr essing Ctrl+Alt+T
• Navigate to a specific member definition by pr essing Ctrl+
• Comment multiple line of codes by pr essing CTRL+K and CTRL+C in sequence or uncomment lines by pressing CTRL+K and CTRL+U in sequence
• Show up the Properties window by pressing F4
• Select code blocks by pr essing ALT + mouse
• Place a breakpoint by pressing F9 on the specified line of code

Common tips

• Download and manage Visual Studio extensions via the Tools|Extension Manager tool
• Add menu items for running external tools via the Tools|External Tools command
• Add IntelliSense code snippets within the code editor by pr essing Ctrl+K or right-click and then Insert Snippet
• Export project or item templates in or der to create reusable templates with File|Export template
• Find all references of a type or member by performing right click inside on a member inside the code editor and then selecting Find All References

About The Authors

Alessandro Del Sole

Alessandro Del Sole, Microsoft Most Valuable Professional (MVP) for Visual Basic since 2008, is well known throughout the global Visual Basic community. The author of four books about .NET development with Visual Studio, he is a community leader on the Italian Visual Basic Tips and Tricks (www.visual-basic.it) web site that serves more than 42,500 VB developers. He is also a frequent contributor to the MSDN Visual Basic Developer Center (msdn.com/vbasic). He enjoys writing articles on .NET development, writing blog posts on both his Italian and English blogs, and producing instructional videos. You can find him online in forums or newsgroups.

Recommended Book

This book’s broad coverage includes advanced features such as generics and collections; a thorough introduction to the Visual Studio 2010 IDE and Visual Studio Team System; a full section on data access with ADO.NET and LINQ; practical overviews of WPF and WCF; coverage of web and cloud development with Silverlight and Azure; and advanced topics such as multithreading, testing, and deployment.

DZone greatly appreciates your support.


Your download should begin immediately.
If it doesn't, click here.

People who downloaded this DZone Refcard also liked:

Getting Started with db4o: Persisting .NET Object Data

By Stefan Edlich and Eric Falsken

About db4o and object databases

db4o is the open source object database that enables developers to store and retrieve any application object with one line of code.

The Object Database (ODB) arrived in the software industry with the advent of object oriented languages. The ODB is primarily used as an application specific database in either extreme scale systems or embedded systems where typical DBA activities are automated.

If you are familiar with object-relational mapping (ORM) tools, then you are already an object database expert because many of the APIs and query languages are comparable. You will even find db4o both familiar and yet simpler to use as ORM tools as there is no requirement for XML mapping, annotations or IDs.

db4o was introduced in 2000 with a focus on performance, compactness, zero administration, simplicity and (the most important of all) native object persistence. Developers were finally able to combine the power of a full database engine with plain undecorated objects.

Getting Started

db4o comes distributed as a few native .NET assemblies. Only Db4objects.Db4o.dll is required for basic db4o operation. Use the Visual Studio "Add Reference" command to add the necessary assemblies. Then use the Solution Explorer to locate the new reference, right-click and open the properties window to ensure that "Copy Local" is set to true for each db4o assembly. This will copy the necessary db4o libraries to your application's bin folder automatically when compiling your project.

Required Environment

Developing with db4o requires only the .NET SDK version 2.0 or better. (3.5 suggested)

Visual Studio 2008 or better is suggested for the best experience, but any .NET IDE will do. Microsoft Visual Studio 2008 Express editions are available for free download from Microsoft.

Running db4o requires only the .NET Framework to be installed. Some hosting environments, such as shared website hosting providers, do not allow code to run with full trust. When the environment is configured to run with reduced trust, all basic database operations require at least ReflectPermission (MemberAccess and ReflectionEmit) for the classes and types being persisted.

Required Libraries per Database Feature

Depending on the features your application requires, reference and distribute these assemblies when you distribute your application:

ObjectManager for Debugging

Included in the db4o distribution you'll find the installer for ObjectManager Enterprise (OME) which, once installed, will integrate into your Visual Studio Environment and allow you to open and inspect, query, and edit (value types only ) object instances stored in your database file.

Basic Database Operations

A Complete Example

IObjectContainer db =
Db4oFactory.OpenFile([filename]), ([config]);
try{
	// Store a few Person objects
	db.Store(new Person("Petra"));
	db.Store(new Person("Gallad"));
	// Retrieve the Person
	var results = db.Query<Person>(x => x.Name == "Petra");
	Person p = result.First();
	// Update the Person
	p.Name = "Peter";
	db.Store(p);
	// Delete the person
	db.Delete(p);
	// Don't forget to commit!
	db.Commit();
}
catch{
	db.Rollback();
}
finally{
	// Close the db cleanly
	db.Close();
}

Create or Open a Database File

IObjectContainer container = Db4oFactory.OpenFile([filename]);

While a db4o database file is open, it is locked and cannot be accessed by another application at the same time.

In traditional relational databases, it's common to open a connection, get/update data, close connection, and then perform your operation. Because db4o uses the native object (or referential) identity, it's better to open the database or connection when your application begins, do all your work, then close the database when your program is shutting down. You'll see why when we get to updating an object with our changes.

Starting a db4o Server

By default, the db4o server runs in-process within your application. To start a db4o server, place this code into your application:

IObjectServer server =
	Db4oFactory.OpenServer([filename], [port]);
server.GrantAccess([user], [password]);

To shut down the server:

server.Close();

The port parameter specifies the network port number. Acceptable values are any number above 1024 which are not already in use.

The GrantAccess() method must be called for each username/ password combination. It is not required at all for embedded servers.

Connecting to a db4o Server

After starting a db4o server instance, use either of the commands below to open a db4o client connection:

// In-Process mode (embedded server)
IObjectContainer client = server.OpenClient();
// Client/Server mode (remote server)
IObjectContainer client =
	Db4oFactory.OpenClient([serverAddress], [port], [user],
[password]);

To close the client connection to the server:

client.Close();

Storing an Object

db.Store(anObject);
db.Commit()

Just one line of code is all it takes. All of an object's properties and child objects will be stored.

Updating an Object

db.Store(anObject);
db.Commit();

Looks familiar? You can use the same Store(object) command to update an object. One difference, however, is that db4o will (for performance reasons) not automatically check child objects for changes.

There is one more thing to be aware of: db4o uses an object's native identity (referential identity) to identify an object and map it to the stored instance of the object. This means that there is only ever 1 instance of an object in memory for each stored instance of the object. (per ObjectContainer or connection) This is important when dealing with class instances that may come from ASP.NET ViewState, Web Services, Interop, or any other serialized source of object data.

Deleting an Object

db.Delete(anObject);
db.Commit();

You didn't think it was any harder than that, did you? Like updates, db4o will not automatically delete child objects unless you configure cascading deletes for your object will remain in memory until the objects are refreshed or garbage collected.

Database Transactions

Whenever you start making changes to your database (using the Store() and Delete() commands) you are automatically in an open transaction. To close the transaction, use the Commit() method:

db.Commit();

Your changes will be permanently saved. If you wish to cancel or roll back any uncommitted changes, use the Rollback() method:

db.Rollback();

Closing a database cleanly will automatically call Commit() for you, so any uncommitted transactions are committed automatically.

If the database is not closed cleanly, or if the application crashes at any time and uncommitted (or incomplete) transactions are discarded.

Queries

Query by Example (QBE)

QBE lets you pass db4o an example object. db4o will search and return all objects which match the object you specify. To do this, db4o will reflect all of the properties of the object and assemble all non-default property values into a single query expression.

Here's an example QBE query that will contain all Customer objects with "Lee" as their Surname:

Customer proto = new Customer ()
	{Surname = "Lee"};
IObjectSet result = db.Get(proto);

Native Queries (NQ)

Like any query language, Native Queries are capable of expressing complex parameterized constraints, however NQ also have the benefit of being 100% compiler checked and can be refactored using common code refactoring tools. NQ can do all this because they are expressed as native .NET code rather than as strings (like SQL statements)

// NQ Lambda Expression (.NET 3.5 syntax)
var result = db.Query<type>(
	o => [boolean expression]);
// NQ Anonymous Method (.NET 2.0 syntax)
IList<type> result = db.Query<type>(
	delegate(type o){
		return [boolean expression];
	});

Native Query Examples

// Query all instances of a type.
IList<User> result = db.Query<User>();
// Query Users by Name.
IList<User> result = db.Query<User>(u => u.Name == "Joe");
// Query Users with at least 10 orders
IList<User> result = db.Query<user>(u => u.Orders.Count >= 10);
// Complex Query
IList<User> result = db.Query<User>(
	u => u.Name.StartsWith("Bob")
		&& (u.Country == "Canada" | |
			u.Country == "USA" );

Sorting Native Queries

Native Query results can be sorted by using an IComparer or a comparison delegate. Here is the query syntax:

IList<User> result = db.Query<User>([predicate],[comparer]);

And here's an example:

// All users with "Smith" in their name
// sorted by name
IList<User> result = db.Query<User>(
	u => u.Name.Contains("Smith"),
	(u1, u2) => u1.Name.CompareTo(u2.Name)
	);

LINQ Queries

LINQ was introduced by Microsoft .NET Framework version 3.5 (also called C# 3.0) in November 2007. To enable the use of LINQ queries, you'll need to add a reference to the Db4objects.Db4o.LINQ.dll assembly and import the Db4objects.Db4o.LINQ namespace. (with a using statement)

A full description of LINQ syntax will not fit in this document. You can find the URL to Microsoft's LINQ reference in the Resources section at the end.

LINQ Queries have all the benefit of compiler checking and automated code refactorability that Native Queries have, but are expressed in syntax more familiar to SQL developers. Here's one quick and easy example that gets all of the Customers with "Smith" in their name, and sorts the results by name.

var results =
	from Customer c in db
	where c.Name.Contains("Smith")
	orderby c.Name descending
	select c;

With LINQ queries you can:

• Use ORDERBY to sort the results.
• Use JOIN expressions to filter one dataset based on the contents of another.
• Use Aggregate Expressions to get the sum, min, max, or average values and GROUPBY to group the results.
• Use Anonymous Types to get back only the fields you wish.
• Use an expression to process, filter, or format the data as it is returned from the database.
• Use LINQ extensions like First(), Any(), All(), Single(), and ElementAt() to access or constrain the result set.

SODA Queries

SODA query expressions are a standard that was present in all but the earliest versions of db4o. Using combinations of SODA query and constraint keywords, you can build up what is called a query "graph". A graph is a network of objects which represent a segment of data.

In this example, we're querying for all of the customers named "Smith".

IQuery query = db.Query();
query.Constrain(typeof(Customer));
query.Descend("Name").Constrain("Smith");
IObjectSet results = query.Execute();

And in this more complicated example, we'll use a compound constraint:

IQuery query = db.Query();
query.Constrain(typof(Customer));
IConstraint c1 = query
	.Descend("Name")
	.Constrain("Smith");
IConstraint c2 = query
	.Descend("Country")
	.Constrain("USA");
c1.And(c2);
IObjectSet results = query.Execute();

Notice how each of the calls to Constrain() will return an IConstraint? You can keep references to those constraints and then use constraint keywords like And(), Or(), and Not() to relate the constraints together, as we did at the end of that example.

Note that the Descend() method returns an IQuery too. So you could Descend() into an object, and then Execute() at a deeper level to return only the matching child objects, like in this example:

IQuery q1 = db.Query();
q1.Constrain(typeof(Customer)); // start with Customers
q1.Descend("Name")
	.Constrain("Smith");
IQuery q2 = q1.Descend("Orders"); // constrain Orders
// Order totals greater than $100.
q2.Descend("Total")
	.Constrain(100)
	.Greater();
// Since we want to return Orders, execute q2 instead of q1
IObjectSet results = q2.Execute();

Query Performance

• If you are experiencing poor NQ performance, then you probably forgot to either enable run-time optimization of Native Queries (by including a reference to the assemblies listed in the "Required Libraries" section) or running Db4oTool.exe on your compiled assembly.
• You can change the Query EvaluationMode configuration to control how and when a query should be evaluated. (See below in the Configuration section)
• You can index fields to aid query evaluation. Indexing fields causes db4o to store the values of the field in a separate index lookup table in the db. As a result, when evaluating the query, db4o does not have to seek through all of the object data to resolve the query results. (See the Class-Specific Configuration Options below)

Dealing with object activation

When dealing with objects that may have relations to other objects quite deep (think of the path of data from Customer to Order to OrderItem to Product with relations to Address objects for billing and shipping and then PO and payment transactions) it would be quite expensive to have to pull all of that data into memory from the DB if all you wanted was the Customer object. Modern object databases use the idea of activation to control the depth to which objects are instantiated and populated when retrieved from the database.

With an ActivationDepth of 5, objects will be populated up to 5 levels deep. Properties of the 5th descendant object will have their values left as default or null.

If you encounter an object that is not yet activated, you can pass it to db4o for manual (late) activation:

db.Activate([unactivatedObject], [depth]);

Objects can also be manually de-activated:

db.Deactivate([activatedObject], [depth]);

Fine-grained activation depth can be configured per class. (see ActivationDepth in the Configuration section below) Activation can also be managed transparently using Transparent Activation. (see below)

Configuration

For all but the simplest db4o use cases, you'll probably want to specify one or more configuration settings when opening your db4o database:

IConfiguration config =
Db4oFactory.NewConfiguration();
// Set configuration properties here
IObjectContainer db= Db4oFactory.OpenFile([config], [filename]);

The IConfiguration object must be passed in the call to open the db4o file, server, or client connection.

Query EvaluationMode

This property controls when and how much of a query is executed.

IConfiguration config =
	Db4oFactory.NewConfiguration();
config.Queries().EvaluationMode([mode]);

Global UpdateDepth

We said earlier that when calling Store() to update an object graph, that db4o will not (by default) descend into child objects to detect changes to the graph. If you know that you'll be often changing child properties, or when changing a parent object often results in changes to child objects, then you may want to change the UpdateDepth.

IConfiguration config =
Db4oFactory.NewConfiguration();
config.UpdateDepth([depth]);

The default value 1 means db4o will not descend into child objects when updating stored object instances.

Setting the UpdateDepth to int.MaxValue will cause db4o to descend as deeply as possible to look for changes.

Setting the UpdateDepth to 0 will prevent any changes from being saved to the database.

Global ActivationDepth

As explained in the section on Dealing with Object Activation, the ActivationDepth controls how much data is loaded when an object is retrieved from the database.

Iconfiguration config =
	Db4oFactory.NewConfiguration();
config.ActivationDepth([depth]);

The default value of 5 is a good balance for most applications, but developers should balance this against the weight of their classes and their access patterns.

Setting the ActivationDepth to int.MaxValue will cause all related objects to be instantiated as deeply as possible, restoring the entire object graph to memory.

Setting the ActivationDepth to 0 will cause nothing to be activated. The object returned will have none of its values loaded. You can then call the Activate(object, depth) method to manually activate the object as described above.

Transparent Activation (TA)

The Db4oTool.exe tool found in the distribution bin folder can be used to instrument your classes to perform activation on-demand transparently as you navigate between object references. When accessing a child object, db4o can automatically activate the child object from the database if it is not yet already activated.

Transparent Activation must be enabled in the configuration when opening a db4o database and your compiled assembly must be instrumented by Db4oTool.exe as part of the build (as an MSBuild task) or post-build by running the tool manually.

Using Db4oTool.exe is not complicated, but is beyond the scope of this DZone Refcard. You can find complete instructions in the db4o reference documentation.

Cascading Operations, call backs and class-specific configuration

The global UpdateDepth and ActivationDepth configurations are good for general testing. But oftentimes, you will want to configure specific behaviors per-class-type, or per-field. (e.g. field indexing)

IConfiguration config =
Db4oFactory.NewConfiguration();
//Get the class-specific canfiguration
IObjectClass objectClassConfig =
	config.ObjectClass([typeName]);
//Get a field-specific configuration
IObjectField objectFieldConfig =
	objectClassConfig.ObjectField([fieldName]);
// Usually shortened to one line. e.g. config.
objectClass(typeof(Customer)).ObjectField ("Name").Indexed(true);

A full description of Class-specific and field-specific configuration settings can be found in the db4o reference documentation.

db4o also allows you to specify event handlers when an object is retrieved, activated, deleted, etc. These events can be handled globally using the EventRegistryFactory or individually within your classes using any of the IObjectCallbacks methods like objectOnActivate, objectOnDelete, and objectOnNew. These handlers are great for selectively activating, refreshing, or cascading db operations.

Lastly, setting the Transient attribute on your class's field members will prevent db4o from storing the values of those fields. When read from the DB, these members will always be left at their default (null) values, useful for remote connections, non- native data (interop) and temporary state.

db4o Resources

About The Author

Prof. Dr. Stefan Edlich

Prof. Dr. Stefan Edlich is a senior lecturer at Beuth University of Technology Berlin (App.Sc.) with a focus on Object Databases, Software-Engineering and E-Learning. He sold his first commercial software in 1986 and has a 26 year software development experience. Furthermore he is the author of ten IT books he wrote for Apress, OReilly, Spektrum / Elsevier, and other publishers. In 2008 he set up the the worlds First International Conference on Object Databases (ICOODB.org) which is continued 2009 at ETH-ZÜrich.

Eric Falsken

Eric Falsken is a longtime web and embedded software developer. He wrote his first of many websites in 1995, and went on to e-commerce, enterprise and internet media before shifting his focus to embeded device software, where he found his love of object databases and db4o. Eric has been a member of the db4o team since 2006, and enjoys travel adventuring, meeting new people, and looking at beautiful code.

Recommended Books

The Definitive Guide to db4o is the first book to comprehensively cover this project in detail. You will learn about all relevant topics, including installing and configuring db4o, querying and managing objects, performing transactions, and replicating data. To aid newcomers to the topic, early chapters cover object database fundamentals, as well as technical considerations and migration strategies. The book is complete with numerous C# and Java examples, so you'll be able to follow along regardless of your chosen language.

---

BUY NOW

books.dzone.com/books/definitive-db4o