Can Of Code

Tag Archives: .net

C# Quick LINQ example

Recently I’ve been working with LINQ so I thought i’d do a quick post to share the two basic LINQ approaches.

First up is an example of a query that returns a collection of objects. In this case they are RouteItem objects.

 

// The LINQ Query
var routesInDB = from RouteItem route in DB.routeItems select route;

// Populate a ObservableCollection with the query results.
routeItems = new ObservableCollection<RouteItem>(routesInDB);

 

The second example is for when you want to get one item from a query similar to “SELECT TOP 1” or  “SELECT … Limit 1” in SQL.

 

 // The LINQ Query
IQueryable<setting> cityQuery = from c in DB.setting where c.ID == 1 select c;

// populate the setting object with the query result.
setting sett = cityQuery.FirstOrDefault();

 

The example above shows the returning of a single setting object instead of a collection.

The final example shows how to get the number of results. This may be useful if you wanted to see if an item was already present in the collection.

 

// The LINQ Query
var query = from c in routeItems where c.routeName == "home" select c;

// get the size of the returned result set.
int size = new ObservableCollection<RouteItem>(query).Count;

 

This example shows a query to count how many RouteItems have the name “home”. We place the result into an int variable.

 

Posted in c#, WPF | Tagged , , , | Leave a comment

5 Cool WPF features for WinForms Devs

Today i have finally booked my exam for the MCTS 70-511. Booking the exam made me reflect and just how much i had discovered about WPF since starting to revise for the exam. When i started, i had only had around a year experience with WinForms and C# and around 0 weeks of WPF development.  So here are 10 things i have discovered for anyone else who might be still working with WinForms.

 

1. XAML, XAML, XAML!

With WinForms you have two choices, you can use the interface designer and drag and drop components into your form or you can create and configure your components in code. Which ever one of those you choose, it will chuck up some C# in a class somewhere. Then WPF comes along looking all pretty with its XAML code. XAML is very similar to HTML in the sense you have elements and a hierarchy. If you have worked with something like android development this kind of XML/HTML style interface design will be familiar.

Why its cool:  Its Cool because it gives you much more control and structure to your interface. More importantly it makes increasingly readable layout code.

Find out more at: XAML Overview (WPF)

 

2. Control Templates, Gray is so last year!

When working with WinForms, if you want to customize the way a control (e.g. a button) looks you are only really faced with changing simple properties like the foreground, background, font etc. WPF has changed all that, with control templates you can visually change the control completely. You can choose what your control will show and how it will do it, you can place other controls within your control, e.g. placing a checkbox within a button.

Why its Cool: No more boring gray controls, you can make controls look however you want and its pretty simple to do.

Find out more: Customizing the Appearance of an Existing Control

 

3. Data Binding, The best of WPF by far

It would be a terrible crime not to talk about Data Binding when talking about WPF. Once you start using Data Binding your wonder why you spend so long writing endless SQL statements in click events. The idea of Data binding is to take away a lot of the pain of updating your source when you make a change in your application. Data binding will with a little encouragement detect when a user changes a field in your UI and will then proceed to update that value within your object which will more then likely be in a collection which will also be notified of the change. This means instead of having code all over the place updating your source (for example SQL Update statements) you can just have simple update code within your object model (your class you use to create your Customer Object for example) that does all the magic.

Why its Cool: It will save you a fair chunk of time doing boring update code. I also find it forces you into using OO design which can only be a good thing.

Find out more: Data Binding Overview

 

4. ClickOnce, Deployment without the hassle.

I know what your thinking, “you can deploy WinForms applications with ClickOnce”. That is correct but i don’t think it gets the attention its due so i am giving it 5 minutes of fame. If you have ever had to deploy your application to more then a few people, you would of had to create an installer. Unless your a programming God you would properly have to send out a new version of your application to fix some bugs. This can be painful, sometimes users might not of got the memo, some users might be scared to death of Installers after they opened that questionable attachment in their emails. ClickOnce may not be very configurable but it does offer a massive time safer. A integrated Updating functionality. With ClickOnce you can set a minimum required Version, you can get the application to check for updates when the app is opened or when the user exits. You can even create check for updates functionality within your application.

Why its cool: It makes updating your user base much much easier. This will save you a lot of time. It can also automatically publish itself to your FTP or network location.

Find Out more: ClickOnce Deployment Overview

 

5. Resource Dictionaries, CSS for .NET

XAML allows you to create styles and brushes. So what? well resource dictionaries are a revolution in recycling. You can define all your styling information (what color your buttons background is, what size font to use) within a resource dictionary, you can then  reuse the resource dictionary not only within the same application but also if you place the resource dictionary in a separate Library you can then use those styles within other projects. This is pretty handy if you are likely to produce a number of applications that will share a consistent style as you only have to define the style once and all your applications will use the styling information. Resource dictionaries are also very versatile, you can set a style that will  automatically change every control of that type or you can give a resource a key and then reference that key within the controls you want to use the style.

Why its Cool: Its all about recycling, recycling saves time. what more do you want!

Find out more: Resources Overview

 

I hope that’s helped inspire those of you who are still using WinForms to move over to the WPF side.

Posted in Software, WPF | Tagged , , , , , , , | Leave a comment

C# Modifying a Application Settings Connection String

On the application I have currently been working on I discovered a small issue. The connection string was stored as a Application setting which meant it was read-only. Its important to set the connection string as a ConnectionString type within the Application settings so that its secure.

But what happens if the connection string changes? This isn’t so bad in a internal application as you can just rollout a new build, but what if each user is likely to have a different connection string.

To change the connection string, help (as usual) came from stack overflow Programmatically change connection string.

That was all fine and dandy but when I went to go and use the application setting by going:

Properties.Settings.Default.ConString;

It returned the old unchanged connection string. the simple way round it was instead of getting the connection string using the code above I had to do this:

System.Configuration.Configuration config2 = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
 pconnectionString = config2.ConnectionStrings.ConnectionStrings["ConString"].ToString();

Bingo! that worked!

 

 

Posted in c#, Software | Tagged , , | Leave a comment