Visual Studio LightSwitch Team BlogThe easiest way to create business applications for the Desktop and the Cloud
Visit the LightSwitch Developer Center | Ask Questions in the LightSwitch Forum
Become a LightSwitch Fan
A common request that the LightSwitch team receives is to provide a control to deal with many-to-many relationships (ex. the relationship between Categories and Blog Posts). One of the more common ways to deal with this is by displaying a list of checkboxes or a tree of checkboxes. We've just released it an extension that provides this functionality. Here's a quick list of the extension's functionality:
You can download the extension and find instructions on how to use it here:
Many to Many Control for Visual Studio LightSwitch
Drop-down lists in Visual Studio LightSwitch are represented by the Auto Complete Box control. This control allows the user to select from a list of values, either coming from another table or a static list of choices defined by a Choice List property. There’s a lot of nice things you can do with drop-down lists to make the user experience better on your screens. Check out the following articles on my blog for more information:
Enjoy, -Beth Massi, Visual Studio Community
For the month of December I’ve been writing a series of articles aimed at the beginner developer getting up to speed with Visual Studio LightSwitch. Even though there’s a ton of information out there on building LightSwitch applications (especially on the LightSwitch Developer Center), I wanted to pull together a cohesive set of entry-level articles that focus on the most important concepts you need to learn in order to build any LightSwitch application. If you’re just getting started with LightSwitch development, this is a great place to start.
Happy Holidays! -Beth Massi, Visual Studio Community
Would you like a more customized login experience for the users of your LightSwitch application? Perhaps the company logo needs to be prominently displayed or the company colors used as a theme? Check out Matt Thalman's new blog post featuring a step-by-step guide for creating a custom login page.
Read: Creating a Custom Login Page for a LightSwitch Application
Pluralsight provides a variety of developer training on all sorts of topics and they have generously donated some LightSwitch training for our LightSwitch Developer Center!
Just head on over the the LightSwitch “How Do I” video page and on the right you’ll see three video modules with over an hour and a half of free LightSwitch training!
1. Introduction to Visual Studio LightSwitch (27 min.)
2. Working with Data (30 min.)
3. Working with Screens (37 min.)
Also, don’t forget to check out all 24 “How Do I” videos as well as other essential learning topics on the Dev Center.
Happy Learning!
Check it out, the November issue of MSDN Magazine is online and our very own Mike Wade has an article about deploying LightSwitch apps to Azure.
In this article Mike Wade shows how to deploy an application built using Visual Studio LightSwitch to Windows Azure, which eliminates the need to dedicate resources to infrastructure management.
Read: Deploying LightSwitch Applications to Windows Azure
Enjoy!
Check it out, The Code Project has created a LightSwitch developer contest!
Do you have what it takes to be a LightSwitch Star? Show us your coolest, most productive, LightSwitch business application and you could win a Laptop and other cool prizes!
Prizes will be issued monthly for two categories: Most Efficient Business Application and Most Ground-breaking Application. Your submission is eligible to win every month! There’s also a grand prize at the end of the contest for each category – an ASUS U31SD-DH31 Laptop!
Just answer the questions on the submission template and either create a YouTube video or write an article for Code Project explaining your application or extension. They’re looking for apps that show off the most productivity in a business as well as apps that use extensions in a unique, innovative way.
Become a fan of LightSwitch on Facebook and post a link to your contest entry on our wall and let people know they should rate it!
Follow us on Twitter and tweet your link to your contest entry to @VSLightSwitch with hash tags #LightSwitch #LightSwitchStarContest so we know to check it out!
Please see the official contest page on The Code Project for all the rules and instructions.
We can’t wait to see what you guys come up with! Good luck everyone!
Check it out, we released a new “How Do I” video on the LightSwitch Developer Center:
How Do I: Handle Database Concurrency Issues?
In a multi-user environment, when two users pull up the same record from the database and modify it, when the second user saves the data it raises a data conflict because the original values do not match what is stored in the database anymore. In this video you will learn how LightSwitch handles these database concurrency issues out automatically as well as how to control what happens yourself in code.
Watch all of the LightSwitch “How Do I” videos here!
Check it out! We just released a new How Do I video on the LightSwitch Developer Center. I created this one based on suggestions from you so I hope you like it!
How Do I: Create Custom Search Screens in LightSwitch?
In this video you will learn a couple techniques you can use when creating custom search screens. You will see how to create custom queries to provide specific search criteria with limited choices, search within a range of dates, as well as provide a filter by related parent records.
LightSwitch has built-in support for SQL Server and SharePoint data sources. To access other data sources, you can write a custom WCF RIA DomainService. This post will show you how to read and write from an Odata Service by wrapping access to it in a DomainService.
There are a couple limitations on the OData Services that can be exposed using RIA Services and LightSwitch.
While both OData and RIA Services support complex types on entities, LightSwitch does not. If a complex type property is exposed on an entity, LightSwitch will import the entity, ignoring that property. There are a couple of workarounds for this that we will detail in another blog post.
An OData service can contain navigation properties that are not associated with any foreign key. This is likely the case with many-to-many relationships, but can also occur for 0..1-Many or 1-Many relationships. For example, the Netflix OData Catalog contains a many-to-many relationship between Titles and Genre. Unfortunately, RIA Service associations are foreign key based. If an OData association is not foreign key based, there isn't a good way to represent it over a RIA Service.
If an OData service does contain these types of associations, there isn't currently a way to represent these in LightSwitch. However, you can add parameterized queries on your RIA Service that can be called LightSwitch. Using this functionality, queries that represent these unsupported associations could be exposed. For Netflix, for example, you could define GetGenresByTitle and GetTitlesByGenre queries on your RIA Service, which call into the appropriate OData navigation properties.
The basic steps to create an OData wrapper DomainService for LightSwitch are as follows:
Steps 1-5 are covered in the How to create a RIA service wrapper for OData Source post. This blog post will build on and update the DomainService created in that post.
The first blog post assumed that the address of the OData service was hard-coded in your DomainService. We will now modify our class to allow the address to specified when consuming the RIA Service from LightSwitch.
The Add Data Source wizard in LightSwitch will prompt developers for a connection string when adding a DomainService data source. This connection string will be stored in the web.config for the project using the class name of the DomainService. We'll modify our DomainService to get the connection information from the web.config in its Initialize method.
First add references to System.Web and System.Configuration.
Add a Description attribute to the DomainService class. This description will be displayed in the Add Data Source wizard when requesting a connection string from the user.
<Description("Specify the address to the ProductCatalog Service")> _
Public Class ProductService
Inherits DomainService
Modify the Initialize method to check for and use the address specified from LightSwitch.
Public Overrides Sub Initialize(ByVal context As System.ServiceModel.DomainServices.Server.DomainServiceContext)
MyBase.Initialize(context)
'Get connection information from the web.config
If Web.Configuration.WebConfigurationManager.ConnectionStrings(GetType(ProductService).FullName) Is Nothing OrElse String.IsNullOrWhiteSpace(Web.Configuration.WebConfigurationManager.ConnectionStrings(GetType(ProductService).FullName).ConnectionString) Then
Throw New Exception("The address to RIA Service must be provided when attaching to this data source from LightSwitch.")
Else
Dim url As String = Web.Configuration.WebConfigurationManager.ConnectionStrings(GetType(ProductService).FullName).ConnectionString
_context = New ProductCatalog.ProductCatalogEntities(New Uri(url))
End If
End Sub
The Submit method of the DomainService will be called whenever LightSwitch attempts to save any changes for the data source. The Submit method will need to process each changed entity and then save changes to the OData service.
In our OData Service, each Product has an associated Category. To ensure that the reference between Product and Category is correctly maintained, our RIA Service will need to process Categories prior to Products. This is done by re-ordering the set of changed entities prior to processing them. This reordering will need to be customized based on the structure of each OData service. The following class will handle ordering the change set.
Public Class ProductEntitiesComparer
Inherits Comparer(Of Object)
Public Overrides Function Compare(x As Object, y As Object) As Integer
If TypeOf x Is ProductCatalog.Product AndAlso TypeOf y Is ProductCatalog.Category Then
Return 1
ElseIf TypeOf x Is ProductCatalog.Category AndAlso TypeOf y Is ProductCatalog.Product Then
Return -1
Return 0
End Function
End Class
Once the change set has been reordered, we will need to process each record in the change set. This is achieved by calling the base implementation of Submit. The base implementation of Submit simply calls the separate Update, Create and Delete methods for each entity type. We will provide these next.
After each record has been processed, we need to save the changes to the OData service. Since a given save can include more than one record and these records are dependent on each other, we'll need to save in batch mode.
Public Overrides Function Submit(changeSet As ChangeSet) As Boolean
'Reorder the change set to ensure that categories are processed before products. Products are dependent on categories.
Dim c As New ChangeSet(changeSet.ChangeSetEntries.OrderBy(Function(entry) entry.Entity, New ProductEntitiesComparer()))
Dim baseResult As Boolean = MyBase.Submit(c)
_context.SaveChanges(Services.Client.SaveChangesOptions.Batch)
Return True
For each method, we first need to attach the Category to DataServiceContext object. For the Update and Delete methods, we also need to specify what operation is occurring on the attached object. The methods are listed below.
Public Sub CreateCategory(ByVal c As ProductCatalog.Category)
'Add the new category to the service reference context
_context.AddObject("Categories", c)
Public Sub UpdateCategory(ByVal c As ProductCatalog.Category)
'Attach the object to the context and specify that it has been updated
_context.AttachTo("Categories", c)
_context.UpdateObject(c)
Public Sub DeleteCategory(ByVal c As ProductCatalog.Category)
'Attach the object to the context and specify that it has been deleted
_context.DeleteObject(c)
These methods are very similar to those for Category. However, for the CreateProduct method, we need to inform the DataServiceContext that there is a relationship (link) between Product and Category. This will ensure that the newly added Product will be correctly associated with a Category. It is necessary to do this on the "1" side of a relationship.
Public Sub CreateProduct(ByVal p As ProductCatalog.Product)
'Add the new product to the service reference context
_context.AddToProducts(p)
'Need to set link between Product and Category (to ensure that inserts to the database are ordered correctly)
'For existing categories, get the category first
If p.Category Is Nothing Then
p.Category = _context.Categories.Where(Function(c) c.ID = p.CategoryID).FirstOrDefault()
'Set the link between the product and category
_context.SetLink(p, "Category", p.Category)
Public Sub UpdateProduct(ByVal p As ProductCatalog.Product)
_context.AttachTo("Products", p)
_context.UpdateObject(p)
Public Sub DeleteProduct(ByVal p As ProductCatalog.Product)
_context.DeleteObject(p)
This method can be extended to an OData Service with an arbitrary number of entity types. The only modifications that need to be made are in the Submit and the Create<Entity> methods. In the Submit method, the change set will need to be re-ordered to ensure that parent types are processed before their children. In the Create<Entity> methods, the links between entity types will need to be specified on the "1" or child end of the relationship.
Thanks!
Back in August we released a theme called “Metro” that gives you a more modern look to your applications with simple colors and more emphasis on text. You can see some screen-shots here. Today we released an update that addresses some issues found by the community, most notably:
So check out the new version and let us know what you think.
Download the Metro Theme for Visual Studio LightSwitch
Let’s face it: Implementing application security can be daunting. Luckily, Visual Studio LightSwitch makes it easy to manage permissions-based access control in line-of-business (LOB) applications, allowing you to build applications with access-control logic to meet the specific needs of your business.
In this month’s issue of MSDN Magazine we’ve got a feature article on LightSwitch Security you should check out:
LightSwitch Security: Securing Access to LightSwitch Applications
This post describes how to query data in LightSwitch using code and how to determine where that query code is executing. It doesn’t describe how to model a query in the designer or how to write query interception code or bind a query to a screen. If you are new to queries in LightSwitch, I suggest you start here – Working With Queries. This post is all about coding and where the query code executes. The goal of the LightSwitch query programming model is to get query code to execute where it is the best performing; as close to the database as possible.
Here is how things are structured in the LightSwitch query programming model. LightSwitch uses three different Types to perform its LINQ-like query syntax. They are IDataServiceQueryable, IEnumerable and IQueryable.
IDataServiceQueryable – This is a LightSwitch-specific type that allows a restricted set of “LINQ-like” operators that are remote-able to the middle-tier and ultimately issued to the database server. This interface is the core of the LightSwitch query programming model. IDataServiceQueryable has a member to execute the query, which returns results that are IEnumerable.
IEnumerable – Once a query has been executed and results are available on the calling tier, IEnumerable allows them to be further restricted using the full set of LINQ operators over the set of data. The key thing to remember, though, is that the data is all on the calling tier and is just being filtered there. LINQ operators issued over IEnumerable do not execute on the server.
IQueryable – This is the interface that provides the full set of LINQ operators and passes the expression to the underlying provider. The only place you will see IQueryable in LightSwitch is in the _PreprocessQuery method, which always resides on the service tier. Since this post is just about coding, we won’t be talking about IQueryable.
Next, let’s talk about the members that get generated when you model an entity with relationships in LightSwitch. These are the members that are used in the LightSwitch query programming model.
For each entity, LightSwitch generates:
An entity set member on the Data Source. For example, if you had a Customer entity in your SalesData data source, you’d get an entity set member like this:
C#
this.DataWorkspace.SalesData.Customers
VB
Me.DataWorkspace.SalesData.Customers
For each “many” relationship, LightSwitch generates an entity collection member and query member for the relationship. For example, if you had a 1:many relationship between Customer and Order in your SalesData model, you’d get the following members on Customer:
EntityCollection<Order> Orders; // EntityCollection is IEnumerableIDataServiceQueryable<Order > OrdersQuery;
Orders As EntityCollection(Of Order)'EntityCollection is IEnumerable OrdersQuery As IDataServiceQueryable(Of Order)
Here’s a diagram of the members/types and transitions between them:
Here are some example query scenarios and the code that you could write to solve them. The code for any of these examples can be written anywhere you can write code in LightSwitch, client or server.
Scenario 1: Get the top 10 Orders with the largest discount:
- Using the entity set, the operators are all processed remotely, since they are all supported LightSwitch operators. The query doesn’t execute until it is enumerated in the “for each” statement.
VB:
Dim orders = From o In Me .DataWorkspace.SalesData.Orders Order By o.Discount Descending Take 10
For Each ord As Order In orders Next
C#:
IDataServiceQueryable <Order> orders =( from o in this.DataWorkspace.SalesData.Orders orderby o.Discount descending selecto).Take(10);
foreach (Order ord in orders){ }
Scenario 2: Get the top 10 Orders with the largest discount from a given customer:
- There are two different ways of doing this, one using the Orders member and the other using the OrdersQuery member. One is local, the other is remote. If all of the orders are already loaded, the local query is just fine. The orders may be loaded if you have a list on a screen that contains all orders or if you’ve already accessed the “Orders” member somewhere else in code. If you’re only looking for the top 10 Orders and that’s all you’re going to load, the remote query is preferable.
'Local execution Dim orders = From o In cust.Orders Order By o.Discount Descending Take 10
'Remote execution Dim orders = From o In cust.OrdersQuery Order By o.Discount Descending Take 10
// Local execution foreach (Order ord in (from o in cust.Orders orderby o.Discount descending select o).Take(10)) { }
// Remote execution foreach (Order ord in (from o in cust.OrdersQuery orderby o.Discount descending select o).Take(10)) { }
Scenario 3: Get the top 10 Orders with the largest discount from a query:
- This is a modeled query called “CurrentOrders”. This query executes remotely.
Dim orders = From o In Me.DataWorkspace.SalesData.CurrentOrders Order By o.Discount Descending Take 10 For Each ord As Order In orders Next
foreach (Order ord in (from o in this.DataWorkspace.SalesData.CurrentOrders() orderby o.Discount descending select o).Take(10)){
}
Scenario 4: Sum Total of top 10 Orders with no Discount
- This query retrieves the top 10 orders and then aggregates them locally. The Execute() method is what executes the query to bring the orders to the caller.
Dim suborders = From o In Me.DataWorkspace.SalesData.Orders Where o.Discount = 0 Order By o.OrderTotal Descending Take 10
Dim sumOrders = Aggregate o In suborders.Execute() Into Sum(o.OrderTotal)
decimal sumOrders = (from o in application.DataWorkspace.SalesData.Orders where o.Discount == 0 orderby o.OrderTotal descending select o).Execute().Sum(o=>o.OrderTotal);
Scenario 5: Sum Totals of top 10 Orders with no Discount from a Customer
- Again, there are two different ways of doing this, one using the Orders member and the other using the OrdersQuery member. One performs the first part of the query locally, the other is remote. The same rule applies as Scenario 2: If all of the orders are already loaded, the local query is just fine. If you’re only looking for the sum of the top 10 Orders and that’s all you’re going to load, the remote query is preferable.
'Local execution Dim sumOrders = Aggregate o In cust.Orders Where o.Discount = 0 Order By o.OrderTotal Descending Take 10 Into Sum(o.OrderTotal)
'Remote & local execution Dim ordersQuery = From o In cust.OrdersQuery Where o.Discount = 0 Order By o.OrderTotal Descending Take 10
Dim sumOrders = Aggregate o In ordersQuery.Execute() Into Sum(o.OrderTotal)
// Local execution decimal sumOrders = (from o in cust.Orders where o.Discount == 0 orderby o.OrderTotal descending select o.OrderTotal).Take(10).Sum(o=>o.OrderTotal);
decimal sumOrders = (from o in cust.Orders where o.Discount == 0 orderby o.OrderTotal descending select o.OrderTotal).Take(10).Sum(o=>o.OrderTotal);
// Remote & local execution decimal sumOrders = (from o in cust.OrdersQuery where o.Discount == 0 orderby o.OrderTotal descending select o).Take(10).Execute().Sum(o=>o.OrderTotal);
Scenario 6: Sum Totals of top 10 Orders with no Discount from a query
- This is very similar to the previous scenario, except calling the modeled query always executes remote. The sum is still performed locally.
Dim orders = From o In Me.DataWorkspace.SalesData.CurrentOrders Where o.Discount = 0 Order By o.OrderTotal Descending Take 10
Dim sumOrders = Aggregate o In orders.Execute() Into Sum(o.OrderTotal)
decimal sumOrders = (from o in this.DataWorkspace.SalesData.CurrentOrders() where o.Discount == 0 orderby o.OrderTotal descending select o).Take(10).Execute().Sum(o=>o.OrderTotal);
I hope these scenarios have helped you see how the LightSwitch query programming model is there to help you write the queries you need while helping to keep things as performant as possible. Happy Querying!
Now that the Visual Studio LightSwitch community is really growing I thought I’d start posting some of the cool articles, videos, samples and extensions I find each month. First off, here are the LightSwitch team “hangouts” where you can get training, ask questions, and interact with the LightSwitch team. The biggest one of course is:
This is your one-stop-shop to training content, samples, extensions, documentation, podcasts, a portal to the forums, community, and much more. All of the team content is aggregated onto this site, and we also aggregate all the community submitted extensions and samples. It’s the first place you should go if you’re just learning LightSwitch. Also here are some other biggies:
LightSwitch MSDN Forums LightSwitch Team Blog LightSwitch on Facebook LightSwitch on Twitter (@VSLightSwitch, #VisualStudio #LightSwitch)
There are a number of times when a LightSwitch application works perfectly on a developer’s machine, but as soon as it has been deployed to an Internet Information Services (IIS) machine, it no longer works. Problems can range from IIS not being configured correctly to the database connection string being incorrect. Or an assembly might not have gotten deployed to the IIS machine. I would like to share a few debugging techniques that I regularly use in order to help system administrators diagnose problems in their deployed applications. For more information on how to configure your web server and how to deploy a LightSwitch application, see Beth Massi’s deployment guide.
Before I continue, I’m going to set your expectations correctly. There definitely isn’t a silver bullet that is going to solve any and all problems you will hit when deploying your application. However, what I’m going to provide is a list of steps you can use to diagnose the most common problems we’ve encountered. These steps are the first thing I use when someone stops by my desk and says “I’m having a problem with my application”. If (and when) these steps aren’t able to help you diagnose your problem, they will at least provide you with some good information to take to the forums where others may be able to assist you.
In the LightSwitch world, the dreaded red X is analogous to the Red Ring of Death on an Xbox 360. OK, so a red X in LightSwitch isn’t as catastrophic. You don’t have to send your app away for a month to get it repaired. But it is a major indication of a problem in your application. When your application fails to load data successfully, the screen will display a red X and the tool tip will say “Unable to load data. Please check your network connection and try loading again.”
These red X’s really mean that an exception was thrown by executing the query.
So what do you do?
A little known secret about LightSwitch is that the server has a Diagnostics subsystem integrated with ASP.NET tracing. LightSwitch’s Diagnostics subsystem is a lot more powerful than just telling you what exception was thrown when issuing a query. You can use it to trace through the actions that were requested of the server, and what steps the server took in response to each action. So even if things seem to be working, you can get more information about what your application was actually doing.
Diagnostics is disabled by default when you create a new LightSwitch application. This is for both performance and security reasons. The performance reason is kind of self-explanatory. Even simple tracing on the server will lower its throughput. The security reasons are because any registered user of your application can get to the diagnostics log when it is enabled and when you enable remote machines to see the diagnostics.
There are 5 app settings that control the behavior of the Diagnostics subsystem:
There are two ways to enable LightSwitch Diagnostics.
To change the Web.config, switch your Solution Explorer to “File View”.
Then click on the “Show All Files” tool bar button.
Under the “ServerGenerated” project you will find the “Web.config” file, which you can edit the settings under “configuration/appSettings”.
Open IIS Manager and find your web site on the left side. On the right, double click on the “Application Settings” icon under the “ASP.NET” heading.
You will see the Microsoft.LightSwitch.Trace.* settings which can be edited to your desired settings.
Once you have enabled diagnostics, you can now inspect the information that is being logged in your application. Remember, any request before tracing was enabled won’t show up in the trace information. So you may need to reload your app in order to get the trace logs populated. ASP.NET provides a web site you can load to view the trace log. The URL of the web site is: <Path To LightSwitch App>/trace.axd. So in my Contoso app above the URL is http://MyServer/Contoso/trace.axd. Navigating to this site shows me the following:
As you can see, LightSwitch made 4 service requests when it was loading my application. The first is a call to “GetAuthenticationInfo”. This is used to see if Access Control was set to None, Windows, or Forms. If it is Forms, LightSwitch displays a Log In screen before displaying the application. The second is the call we are interested in: “Customers_All”. This call executes the Customers query. The last 2 are service calls to get whether the current user can Insert, Update, and Delete certain entity types. In my app this was for the Customer and Order types.
Since I know that the “Customers_All” call is the one causing me problems, I click on its “View Details” link to drill into that call. And here I am greeted with a big red message:
I see an exception has occurred “Login failed for user” and the name of the account my IIS Web Application is running under. This tells me that my application tried using the current account to log into the SQL Server database. However, that account isn’t set up as a user on my database. I forgot to change my connection string when I deployed. It was working fine on my development machine because it was running under my account. But once I deployed, it is now running as a different account that doesn’t have privileges to access the database. Changing the connection string to use valid credentials fixes this issue.
I have just walked you through how to diagnose a very common issue: the database credentials no longer work once the application is deployed out into the wild. However, doing the steps outlined above can help diagnose almost all red X issues popping up in your application. You may not immediately see the problem, like we did above, but it will give you information to build up your knowledge on what is going wrong. Using the Diagnostics subsystem is a trick that every LightSwitch developer should have up their sleeve.
Please be aware that tracing, especially remote tracing, should only be used when debugging and deploying your application. When you move your application into production, be sure to set Microsoft.LightSwitch.Trace.LocalOnly to ‘true’ in your application. Also, in production, tracing should only be enabled if you really need it.
So if the red X error described above is ‘dreaded’, the “GetAuthenticationInfo” error message can probably be described as ‘execrated’. (Don’t worry; I had to look it up in a thesaurus.) Many hours inside and outside of Microsoft have been spent trying to debug this error. The problem is, there isn’t just one issue that causes this error. There are seemingly endless issues that cause this error. The reason is explained above. ‘GetAuthenticationInfo’ is the very first service request that LightSwitch is trying to make when your app loads. Thus, if there is any configuration issue with your IIS machine, web app, virtual directory, etc. this error is going to be displayed. Unfortunately, using the diagnostics tracing outlined above isn’t going to help in this situation. More than likely, the service call isn’t even getting into LightSwitch code. As such, our diagnostics isn’t able to log information, since it isn’t getting that far.
So in order to diagnose the problem here, we will use another tool, Fiddler. Fiddler is a tool that every web developer and IT administrator should have at their disposal. It logs all web traffic between your computer and the IIS web server. It will do the tracing that the LightSwitch diagnostics can’t do. Download Fiddler and start the program on your client machine. Then try to load your LightSwitch application again. You should see web requests and responses in Fiddler.
When you start Fiddler, you will see the requests on the left side. To look at the information being exchanged, click on the “Inspectors” tab at the top, and select the inspector for both the request at top and response at bottom. My 3rd request, which was for ‘GetAuthenticationInfo’, returned a ‘500 – Internal Server Error’ response. The text inside shows what the server responded with. Here is says
An application error occurred on the server. The current custom error settings for this application prevent the details of the application error from being viewed remotely (for security reasons). It could, however, be viewed by browsers running on the local server machine. To enable the details of this specific error message to be viewable on remote machines, please create a <customErrors> tag within a "web.config" configuration file located in the root directory of the current web application. This <customErrors> tag should then have its "mode" attribute set to "Off".
An application error occurred on the server. The current custom error settings for this application prevent the details of the application error from being viewed remotely (for security reasons). It could, however, be viewed by browsers running on the local server machine.
To enable the details of this specific error message to be viewable on remote machines, please create a <customErrors> tag within a "web.config" configuration file located in the root directory of the current web application. This <customErrors> tag should then have its "mode" attribute set to "Off".
This error message tells us that an error occurred, but the server doesn’t want to display the details of the error. So we need to configure the server to tell us the error. To do this, you can modify your Web.config to add the “customErrors” section it says to add and then re-publish your application. Or you can modify the settings in IIS Manager. In IIS Manager, navigate to your Web Application on the left side. On the right, under "ASP.NET”, double-click on “.NET Error Pages”.
On the far right side, under the “Actions” group, click on “Edit Feature Settings…”
In the Edit Error Pages Settings, select either “Off” if your client is on another machine, or “Remote Only” if you are using the IIS machine as the client.
Now that custom errors are turned off, hit your application again and look at the Fiddler trace. You should still get a “500 – Internal Server Error” message, but the response should give you better information on what the internal server error was. Now I get:
As you can see, the error message is “Unrecognized attribute 'targetFramework'”. Doing a quick Bing search on that error message tells me that I need to make sure the App Pool that is serving my site is set to the 4.0 framework. So to fix this error, I right click my “Contoso” Web Application in IIS Manager and select “Manage Application” –> “Advanced Settings”. This allows me to change my Application Pool from “Classic .NET AppPool” to the correct “ASP.NET v4.0”. After doing that, I reload my application and everything is working again. (Note: When using LightSwitch deployment, the Application Pool will be set correctly. However in my case someone else accidently changed it.)
As I’ve said, these two diagnosis techniques may not solve every issue you can run into after deploying your LightSwitch application. But they are great first steps that can be taken to help you determine what the error you are running into is. And hopefully with that information you will be able to fix the problem yourself, go to Bing and search on the issue, or go to the LightSwitch Forums and use that information to get a faster resolution.
Grid Logic has released a LightSwitch extension that helps you work with Microsoft Office called the Office Integration Pack. This extension makes it easy for LightSwitch developers to manipulate the 2010 versions of Microsoft Excel, Microsoft Word and Microsoft Outlook in a variety of ways common in desktop business applications. Create documents, PDFs, spreadsheets, email and appointments using data from your LightSwitch applications. This extension is completely FREE and includes source code!
You can download and install the Office Integration Pack directly from Visual Studio LightSwitch via the Extension Manager or you can download it manually from the Visual Studio Gallery.
Available downloads include:
For more details about the Office Integration Pack see Grid Logic’s website: http://www.gridlogic.com/OfficeIntegrationPack
Hello LightSwitchers! I hope you’re all having fun and building cool stuff with RTM. I apologize for the delay of this conclusion of the Course Manager series. In case you missed it, here are the previous posts:
In this post, we will walk through how to design a “Home” screen.
In LightSwitch, you can indicate a screen to be the “start-up screen” of the application. Meaning, the screen will be automatically launched when you start the application. In our case, we want to create a home screen that provides some entry points for different workflows when the user first starts the application.
Let’s first create blank screen to be our home screen. To create a blank screen, you can pick any screen template in the Add New Screen dialog and leave the Screen Data to be “(None).” In our case, we will pick list-detail screen template, name the screen “Home,” and leave the Screen Data “(None).”
Double click on Properties node in Solution Explore to open the application designer.
Select the “Screen Navigation” tab in the application designer. In the menu structure tree, select “Home” and click “Set” at the bottom. This will set the “Home” screen as the start-up screen of the application. Finally, use the up/down arrow buttons on the right to move the “Home” screen to the top of the menu.
If you hit F5 now, you will see the “Home” screen is automatically opened when you launch the application. The menu on the left also reflects the ordering you specified in the application designer.
We have a blank canvas on start-up. It’s time to use some creative juice in designing our home screen. Before we start, let’s draw out what we want to build… and this is what we have:
To sum up, we want:
Let’s draw some boxes around the picture and see how we could create this structure. There are essentially 2 big groups vertically stacked on top of each other:
Let’s go back to the IDE. Double click on “Home” in Solution Explorer to open the screen designer. We will first create the top and bottom group. Since they will be vertically stacked, change the root from “Columns Layout” to “Rows Layout.” Set the Vertical Alignment to “Top” in Properties window, so things will not stretch vertically.
Use the “Add” dropdown to add 2 groups under the Home screen node.
Since the top group horizontally stacks the logo and the text group, change the top group from Rows Layout to Columns Layout. The bottom group is a tab group, so we will use the Tabs Layout.
Next, we want to add a logo to the top group. This logo will be a static image. Meaning, it is an image file that you supply.
In LightSwitch, every visual element you find on the screen content tree needs to bind to some data. In most cases, they are data from the database (such as a student list or grid), or in our case, a static data property.
To create a static data, we need to add a local property. Click “Add Data Item” on the command bar to add a piece of data. In our case, we want a local property of type Image. Name the property “Image_Logo” and click OK.
In the screen designer, drag and drop the newly created Image_Logo to the screen content tree. Let’s put it under the top group we created earlier.
If you run the application now, you will see an image field on the screen:
This is great but not exactly what we want. First, we don’t need a label for “Image Logo.” Second, this is a static image, so we don’t want user to be able to update an image. We can easily take care of these. In the screen designer, change the image control from “Image Editor” to “Image Viewer.”
In Properties (with the Image Logo node selected), set Label Position to “None.”
While we’re at it, we can also change the image size.
If you run the application again, you will now see a blank image on the screen:
This is more like it… well, except there is no image.
Now, we need to wire up the Image_Logo property we created to an image file on the computer.
This process requires a bit of coding. In screen designer, click “Write Code” button in the command bar and select Home_InitializeDataWorkspace.
In the body of the method, assign Image_Logo property to an image file (I have a file called “logo.png”):
Image_Logo = GetImageByName("logo.png")
GetImageByName is a helper function that converts an image file into a byte array. Copy and paste the following helper functions to the screen code.
Private Function GetImageByName(fileName As String) As Byte()
Dim assembly As Reflection.Assembly = Reflection.Assembly.GetExecutingAssembly()
Dim stream As Stream = assembly.GetManifestResourceStream(fileName)
Return GetStreamAsByteArray(stream)
Private Function GetStreamAsByteArray(ByVal stream As System.IO.Stream) As Byte()
Dim streamLength As Integer = Convert.ToInt32(stream.Length)
Dim fileData(streamLength - 1) As Byte
stream.Read(fileData, 0, streamLength)
stream.Close()
Return fileData
Now, we need to add the image file to the project (logo.png). In the Solution Explorer, switch from Logical View to File View.
Right click on the Client node. Select “Add” then “Existing Item.” This will launch a dialog for you to navigate and select your image file.
In this dialog, I will select my “logo.png” file and click Add. The image file will appear under the Client node.
With the image file selected, set the Build Action to “Embedded Resource” in Properties window.
If we run the application again, you will now see the image file you supplied in the screen.
Now we’d like to add some text next to the logo. We will first create a new group to hold this text (title, subtitle, and description). In the screen designer, add a new group below the logo node.
Adding static text follows the same concept as adding a static image. We will first create a piece of static data, in this case, a String (rather than an Image). Click “Add Data Item” button in the command bar, add a local property of type String. Name the property Text_Title and click OK.
Drag and drop the newly created property to the content tree (under the text group).
Change the control from Text Box to Label. Set Label Positions to “None” in Properties window. LightSwitch provides a set of pre-defined text styles for text-based controls. Let’s also set the Font Style property to “Heading1.”
We now need to assign the Text_Title property to some value. Click on Write Code button on the command bar. In screen code, add the following in Home_InitializeDataWorkspace method:
Text_Title = "School of Fine Art - Office of Registrar"
If we run the application now, you will see the title appear on the screen in a larger and bold font.
You can follow the same steps to add a subtitle and description (with different font styles) to the screen.
We’re now ready to move on to the bottom group. Before we begin, create some static images and text data to use for the bottom group. If you look at the Course Manger sample, I’ve added 4 additional images and 4 additional texts.
Now, if you look back at our drawing, we need a table under the tab control. The table consists of 4 columns and 2 rows. Why do we use a table layout instead of rows and columns layout here? Well, you certainly can. Table layout, however, lines things up better in this case. For example, if you need a larger margin between and image and text, you can adjust it for the entire column at once (instead of lining it up one by one). Plus, I need an excuse to show you the table layout J
Add a new group under the tab group. Change the control to Table Layout. Set the Horizontal alignment to “Left” in the Properties window.
Add 4 groups under the Table Layout. These groups will automatically be using the TableColumn Layout. They represent the 4 columns in our table.
The first column contains 2 images. So I will drag and drop 2 image data to the content tree.
Similarly, drag and drop 2 texts to the 2nd column, 2 images to 3rd column, and 2 texts to the 4th column. Change the controls from Image Editor to Image Viewer and Text Box to Label. Set their Label Position property to “None.” If you also set the Height property of the Label to “Auto,” the text will wrap nicely within a table cell.
Let’s run the application and see where we are.
We’re almost there! We just need to add a link for each workflow. We can achieve this by adding a command that navigates to a workflow screen. Right click on the Text Search node and select Add Button.
In the dialog, name the method SearchStudents and click OK.
A command will be added. Change the control from Button to Link.
Double click on the command to go to the code. Write the following to launch the SearchStudent screen when the user clicks on the command.
Private Sub SearchStudents_Execute()
Application.ShowSearchStudents()
Follow the same steps to add the rest of links. Let’s run the application to see the home screen!
In this post, we learned how to set the start-up screen. We added static images and texts (with different fonts). Finally we use the table layout to line up items on our home screen. If you’ve been following the previous blog posts, you have just created the Course Manager app from scratch!
This concludes our Course Manager Sample series. Thank you very much for following!
The LightSwitch team has released a General Distribution Release (GDR) to resolve an issue encountered when publishing to SQL Azure.
In some cases, customers have reported a “SQLServer version not supported” exception when publishing a database to SQL Azure. This is due to a recent SQL Azure server upgrade which caused the version incompatibility. The GDR enables LightSwitch to target the upgraded version. The fix also makes it resilient to future server upgrades.
The GDR and instructions for installing it can be found on the Download Center.
Thank you to all who reported the issue to us. We apologize for any inconvenience.
This morning the LightSwitch Team released samples in both Visual Basic and C# that contain the code for the recently released Metro Theme for Visual Studio LightSwitch.
For more information on creating extensions for Visual Studio LightSwitch, seeVisual Studio LightSwitch 2011 Extensibility Toolkit.
The sample expands upon the Help topic Walkthrough: Creating a Theme Extension, which demonstrates a simple theme that defines fonts and colors. The Metro theme also makes use of styles, defining new appearance and behavior for the built-in LightSwitch control templates. To provide a consistent experience, you will need to define Resource Dictionaries in the form of a .xaml file for each control template, as shown in the following illustration:
Additional styles are defined in the MetroStyles.xaml file, which also contains a MergedDictionaries node that references the other .xaml files. When LightSwitch loads the extension, it reads in all of the style information and applies it to the built-in templates, providing a different look and feel for your application.
There isn't much actual code in this sample; most of the work is done in xaml. You can use this sample as a starting point for your own theme, changing the fonts, colors, and styles to create your own look.
Enjoy,
-Steve Hoag, Visual Studio LightSwitch
Last night the LightSwitch Team released the Metro Theme for Visual Studio LightSwitch on the Visual Studio Gallery. You can also download it directly from the Extension Manager inside Visual Studio LightSwitch.
The Metro theme gives you a more modern look to your applications with simple colors and more emphasis on text. Here’s a screen shot of the Metro theme applied to the Contoso Construction sample application and the Time Tracker Starter Kit:
There are more and more LightSwitch extensions being built and released on Visual Studio Gallery! Check out these latest themes from the community and our partners.
Luminous Themes by Yann Duran (Luminous Software)
In4MA Theme by Jamil MilheM
NetAdvantage for Visual Studio LightSwitch 2011 Vol. 1 Light (Free) This free pack of controls from Infragistics contains two free themes and handy controls. Check out more LightSwitch extensions from Infragistics here.
Want to build your own themes and extensions? Visit the Extensibility tab on the LightSwitch Developer Center to learn how.
Concurrency issues are common in multi-user applications that have a database on the backend.
The good news is that LightSwitch makes concurrency very easy to handle by providing two different mechanisms:
When a conflict is detected, a “Data Conflict” screen is automatically displayed to the user allowing them to choose how to resolve the conflict
Or, for a more customized solution, code can be written so that the application resolves the conflict without requiring interaction from the user
To find out more information on how to handle concurrency issues using LightSwitch, refer to my recent blog post called "How To: Handle Database Concurrency Issues".
Also, check out other "How To" posts on my blog.
~Nicole Haugen
Andrew Brust from Blue Badge Insights has just published a great series of whitepapers on Visual Studio LightSwitch aimed at educating you on what LightSwitch is and what it can do for you. Check out the PDFs below.
What is LightSwitch? This is the first in a series of white papers about Microsoft® Visual Studio® LightSwitch™ 2011, Microsoft’s new streamlined development environment for designing data-centric business applications. We’ll provide an overview of the product that includes analysis of the market need it meets, examination of the way it meets that need relative to comparable products in the software industry, concrete examples of how it works, and discussion of why it’s so important.
Quickly Build Business Apps In this paper we’ll walk through the development of a sample LightSwitch application and experience a wide range of LightSwitch techniques and features as we present configuration examples, illustrating screenshots, and code listings.
Get More from Your Data In this paper we’ll explore how to access external data sources, LightSwitch’s data capabilities, and advanced data access and querying techniques.
Wow Your End Users In this paper we’ll explore the finer points of LightSwitch user interface design, including menus and navigation, screen templates, search, export, and application deployment.
Make Your Apps Do More with Less Work In this paper, we discuss using LightSwitch extensions to bring extra features, connectivity, and UI sophistication to your applications.
More Visual Studio LightSwitch resources -
We've updated the Windows Platform Installer (WPI) feeds for the Visual Studio LightSwitch server runtime components. Previously there was only a single option that would install the server runtime components along with SQL Server Express which we considered to be the primary deployment scenario for LightSwitch applications. We've received feedback to make this optional for scenarios where a full version of SQL Server is installed or the database may be hosted on a different tier. In the latest WPI feed you will now see two options for the LightSwitch server runtime, one that includes SQL Express (which is the same as the previous option) and one that does not include SQL Express.
So... for scenarios where SQL may already be installed or hosted on another computer, choose the option that does not include Local SQL support. See the LightSwitch deployment guide for complete instructions on publishing LightSwitch applications.
We just launched a new feedback site called UserVoice that makes it easy for you to tell us what you want to see in the next versions of Visual Studio LightSwitch. It gathers and sorts ideas by popularity, giving us an immediate view of the most requested features.
Just head to
and then click the “Submit Idea” button.
This will take you to the LightSwitch UserVoice site where you can sign up with email, Facebook, or a Google account. Once registered, you can view ideas submitted by other people and vote on these ideas, or enter new ideas. Each person is given 10 votes to apply across the list of ideas. This way we can tell what’s really important for people.
You are free to move your votes around over time, and when an idea is closed out all votes for that idea are returned to you, so you can apply them to other ideas as we accept or decline the suggestions. Anyone can comment on the ideas submitted. The site is lightweight and designed for making it a pleasant, efficient experience to submit ideas. We’ll be looking at these feature suggestions often so that it influences our feature priorities for future versions of LightSwitch.
Let us know how we can improve Visual Studio LightSwitch!
Thanks, -The LightSwitch Team
I just updated the LightSwitch Deployment guide I wrote back in March for the RTM release of Visual Studio LightSwitch. This guide is meant for people who want to host three-tier LightSwitch applications on their own IIS servers. There was only a couple screen shot updates but now it should be clearer on how to set this up. You can read it here:
Deployment Guide: How to Configure a Web Server to Host LightSwitch Applications