One of the things I needed recently is a simple way to have a textbox that had a watermark in it. Apparantly SilverLight 4 provides it,,, and it doesn’t provide it. Check this post out. I really couldn’t help but laugh when I saw this. ‘Do not use in a Silverlight 4 application.’ and at the same time the supported version is only Silverlight 4. Aaah yes, well the only other solution is to use a watermark textbox someone else has created or to make your own. I opted to make my own. Before we get into the code here it is:

This just gives you a basic idea of what you can do. The first textbox is the user control that has watermark capabilities. If you click on the water marked textbox it will clear it out and be ready for input. If you do not type in any text and leave it blank and click on the second textbox it will replace the watermark. If you click the ‘Get Text’ button it will show blank because you do not want the watermark to count as valid text. If you click ‘Set Text’ it will programatically set the text in the textbox and you will notice that the watermark disappears.

(more…)

Reading an xml file is something that every developer has to do at some point (if not regularly). XML protocol is extremely prevalent across all technologies which makes it important to understand how to parse it. Sivlerlight exposes System.XML.Linq namespace that has all the needed classes to use Linq to query your XML to get the node/s that you need.

Always Starts with the Document

As with every XML reader you start out by creating an instance of the document and then filling it with the XML file’s data. In this case Silverlight provides ‘XDocument’ class to instantiate the document object and then the ‘Load’ method to read the data into the object. Then once we’ve loaded the object with data then we can run a traditional Linq query on the data.

Test Case

So lets run through a test case. Lets say we have a configuration file in which we want to determine what logo to display based on the url that called it. So here is our example xml:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <Logos>
    <Logo url="url1">
      <LoginWindowLogo>/namespace;path/img1.png</LoginWindowLogo>
    </Logo>
    <Logo url="url2">
      <LoginWindowLogo>/namespace;path/img2.png</LoginWindowLogo>
    </Logo>
  </Logos>
</configuration>

And here is the C# code to read it:

XDocument document = XDocument.Load("Config.xml");
 
            var images = (from e in document.Descendants("Logo")
                          where e.Attribute("url").Value == App.Current.Host.Source.Host
                          select new
                          {
                              LoginWindowLogo = e.Element("LoginWindowLogo").Value,
                          }).FirstOrDefault();
 
            if (images != null)
            {
                loginwindowlogopath = images.LoginWindowLogo;
            }

App.Current.Host.Source.Host is the property that gives you the current apps domain, the function ‘FirstOrDefault’ get the results and turn it into an object that just has the properties selected.

An advantage of using Silverlight is the fact that the entire app is cached locally. While this may take a while to download initially, after everything is downloaded the app runs very very fast and only requires you download information asynchronously from a web service. The only problem is, what if you make changes? Since the app is cached those changes are sometimes not downloaded automatically. So what to do? Lars Holm Jensen wrote a nifty little post that shows how you can determine when the last time the silverlight package was was deployed by reading the datetime stamp on the ‘xap’ file. Just in case you didn’t click on the link, here’s the code:

<object id="Xaml1" data="data:application/x-silverlight-2," type="application/x-silverlight-2"
width="100%" height="100%">
<%
string orgSourceValue = @"ClientBin/SilverlightApp.xap";
string param;
 
if (System.Diagnostics.Debugger.IsAttached)
param = "<param name=\"source\" value=\"" + orgSourceValue + "\" />";
else
{
string xappath = HttpContext.Current.Server.MapPath(@"") + @"\" + orgSourceValue;
 
DateTime xapCreationDate = System.IO.File.GetLastWriteTime(xappath);
param = "<param name=\"source\" value=\"" + orgSourceValue + "?ignore="
+ xapCreationDate.ToString() + "\" />";
}
 
Response.Write(param);
%>
 
<param name="onError" value="onSilverlightError" />

The ‘if’ statement checks to see if your debugging. If you are, then grab the latest/greatest. If not, then it’s assumed that you are in production mode and then it checks to see if you have the latest and greatest. If you don’t, then download the latest version. Thanks Lars!

One very important task you have as a developer is to keep track of errors. Errors you ask? ‘Errors’? ‘Not me, I write bug free code!’. Ok Mr. Programming God, but for the rest of us mortals, we have to do something to keep track of all the human errors that get embedded into our code. There are many different ways to store these errors, some people do it in flat files, others in databases. We won’t be talking about where to store these errors, just how to get them from silverlight.

The problem

Web applications have always presented a particular problem when it comes to catching errors and logging them in a central place. First, with Javascript it is difficult to know when an error has occurred and hasn’t been caught already and if so, it’s difficult to do anything after that as many javascript errors will break the app entirely and not run anymore code.

The Solution… A Solution

Silverlight attempts to simplify this process by having a central place to catch any unhandled exceptions and then do something with them. You can catch them in the App.xaml.css file. Here is an example:

private void Application_UnhandledException(object sender, ApplicationUnhandledExceptionEventArgs e)
    {
      //Ignores logging if your debugging
      if (!System.Diagnostics.Debugger.IsAttached)
      {
        /*TODO: Some method to save the 
           the error to a file or database by using
           e.ExceptionObject.Message, e.ExceptionObject.StackTrace
        */
        e.Handled = true;
        ChildWindow errorWin = new ErrorWindow("Error", "An Error has been logged"));
        errorWin.Show();
      }
    }

Does this mean that we don’t need to do any try/catches? No, we still need to handle errors and do something with them, but in the event that we miss an error, it will be caught here and logged so that we can more easily debug the released code.

The Problem

I’ve recently been working on a Silverlight project that connects to WCF services asynchronously (as all Sivlerlight apps do). The issue that no one understood was the fact that these services are not secured in any way. Silverlight is simply a client asking for some information by sending an request with XML and then receiving the XML back. So any programming language that has classes to handle SOAP could easily utilize those web services as they were not authenticated.

The Solution

As an asp.net developer you learn to use asp.net sessions as a way to authenticate and to keep track of that authentication. This works for web services as well. You just have to make sure you have a couple things. First, in your web service you must include ‘System.ServiceModel.Activation’ with the ‘using’ clause and at the top of your web service class implementation you must include the following:

namespace mynamespace
{
[AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
public class mywebservice
{
 
}
}

Once you’ve done this you can include your methods and utilize your session classes:

public void Login(string username, string password)
{
    // check username/password against the database and validate yes or no
 
    if (isLoggedIn)
    {
        System.Web.HttpContext.Current.Session["IsLoggedIn"] = "yes";
    }
}

The last thing that would be needed is to secure the transmissions with SSL. Without this, anyone could sniff the packets to and from a laptop using a public wifi hotspot.

Quick and Easy

A quick and easy way to spawn threads and update the UI from those threads is the following:

new Thread(() =>
               {
 
                   try
                   {
                       Thread.Sleep(3000);
                   }
                   finally
                   {
                       this.Dispatcher.BeginInvoke(() =>
                       {
                           label1.Content = "testing within a thread";
                       });
                   }
               }).Start();

This code starts a new thread and runs it asynchronously to the main thread. The key here is the fact that there is no way to affect the main thread (that the UI is running on) directly from a spawned thread so you have to reference the parent (dispatcher) and call the ‘BeginInvoke’ method and pass it an anonymous function that runs on the same thread that the UI is running on.

Passing Parameters

Sometimes you need to get information in the function you are running. You can do this by passing in parameters into the anonymous function. For example:

new Thread((a) =>
               {
                   try
                   {
                       Thread.Sleep(3000);
                   }
                   finally
                   {
                       this.Dispatcher.BeginInvoke(() =>
                       {
                           label1.Content = (string)a;
                       });
                   }
               }).Start("test");

You have to remember to cast your parameter as it always comes in as an object and requires ‘un-boxing’.

Running external Functions

You can also start a thread on an external void method:

// The code starting the thread
Thread thr = new Thread(new ParameterizedThreadStart(this.test));
            thr.Name = "testthread";
            thr.Start("1");
 
 
       //The void method (object only parameters)
        public void test(object a)
        {
            while (runthread)
            {
                Thread.Sleep(3000);
                this.Dispatcher.BeginInvoke(() =>
                {
                    label1.Content += (string)a;
                });
            }
        }

Notice that in the external method you can only have generic ‘object’ as the parameter and must then cast the data into the appropriate type afterwards.

I have recently been using LINQ to accomplish much of my data abstraction and have found it very useful for building a robust ASP.Net application. Ultimately what LINQ to SQL does is it translates your C# code into a SQL query and returns an object or an object list instead of a dataset. This can be much easier to deal with than a dataset. I have run into a couple things that I didn’t expect so I thought I’d share. (more…)

I’ve recently worked on an application that required a mobile (iphone/Android) to quickly search through data and do it in such a way that it fits the dimensions of the iPhone/Android Phone. One of the great things about Android and iPhone is the fact that both operating systems use safari webkit as their web browser. It is a slimmed down version however it has a lot of the same features as the full blown safari web browser. That being the case, building a web application for the iPhone is also building a web app for the Android phone too. iPhone and Android, however, suffer from the same ailment… Dimensions. Yes it’s true you can browse the web and see websites and it looks almost exactly the same as it does on your desktop PC (minus things like flash), but the problem you run into is that to see the entire website, the browser must shrink the webpage to the point at which you can no longer read the text until you zoom in. Then the content goes off in all directions off the viewable area of the screen and you must drag your screen in each direction to view the content. Fine for a regular website. Not so fine for an application in which you must interact with the content. Most native applications for the iPhone have a prescribed look and feel about them that does a great job making it easy to interact with the area of the screen that you have to work with on the iPhone. A great way of making an iPhone web app is to mimic that same look and feel in a web browser. So how do we do this?

(more…)

So whats up with the hype?

To really appreciate JSON its good to understand XML and why an alternative to XML exists. XML is a powerful robust markup language that makes many things that were formerly very difficult much more feesable. One of those things is data interchange between different systems. Data interchange between different systems has always been possible, however up until recent years it has been very difficult because of the lack of a unified protocol. These days most modern languages and DBMSs have XML parsing functions that allow you to grab the data that you need and search and filter your data with Xpath. XML has many uses. Everything from styling to configuration files to web services and site maps. More recently, XML has been used to encapsulate data in AJAX HTTP requests. XML is very powerful in that it is platform independent so you can conceivably transfer data between multiple operating systems, languages, databases, and other systems and sub systems. You can see what XML looks like here (more…)