bool isRunning = (MyStoryboard.GetCurrentState() == ClockState.Active);

Annonymous Types

var annon = new { name1 = var1, name2 = var2, ... };
// or
obj annon = new { name1 = var1, name2 = var2, ... };

// Example
obj results = new { OriginalRequest = myRequest, Data = foundData, Status = dataStatus };
// Now you can see results.Data!

Limitations
I had originally wanted to use this to pass a complex, dynamic object back from a function, however, I soon found out that this was not possible [without the use of reflection]:

From Rick Strahl’s Blog
One very important aspect to understand about anonymous types is that they are a compiler generated construct. The type is a regular .NET type similar to any other but it has one big limitation: Anonymous types are scoped only to the currently executing method. Because the generated type is anonymous there’s no public name for the type that you can access. In other words you can’t instantiate the type directly on your own and you can’t reference the type outside of the method that created it.

Anyhoot… here is how I have created a pseudo-timer that will spit out the time difference in seconds from when the timer is started to when it is stopped.

Obviously this is simple, and can only time one thing at any given time… but you get the idea.

var startTime;

function startTimer()
{
  // Set the global start time to "now"
  startTime = new Date();
}

function findTimeDiff(message)
{
  // Uses the global startTime.
  // valueOf() spits out in milliseconds, so /1000 to get seconds.
  var diffInSeconds = ((new Date()).valueOf() - startTime.valueOf())/1000;
  alert(message + " [" + diffInSeconds + " seconds]");
}

...

startTimer();
LengthyFunction();
findTimeDiff("Time to run LengthyFunction");

startTimer();
LengthyFunction2();
findTimeDiff("Time to run LengthyFunction2");

But then I decided to add my own context filtering to my grid, where the datagrid source is filtered based on input from the user in a textbox. I used a LINQ query on the List of myClass to do my filtering and when I databound the result of my LINQ query to my datagrid, BAM, the auto column sorting stopped working; the arrows on each of the columns just didn’t show up.

The Problem:
I was a little confused, but after a quick google search it appears that:
1. You must databind to a class that implements the IList interface [gives access to the Sort method] to get the auto sorting to work on a datagrid.
2. My LINQ query returns System.Collections.Generic.IEnumerable.
3. IEnumerable does NOT implement IList, but List does.

The Solution:
Use the ToList() function on the returned IEnumberable to create List of the results so that we DO have access to the Sort() method.

var filteredResults = from x in m_alarmList
  where (x.customProp.Contains(searchVal))
  select x;

_myDataGrid.ItemsSource = filteredResults.ToList();

Thanks to this post: For bringing the difference between IEnumberable and List to my attention.

Silverlight.net FAQ Page
[This link posted 6/4/2009 and may change in the future. At time of posting this was based on Silverlight 2]

Some of the topics I found interesting include:

• XML Namescopes and when new namescopes are created
• Cross domain policies
• What graphic features are and are NOT included in Silverlight 2
• How to properly use Storyboards on multiple elements
• Using InitParams to get data into your Silverlight app
• How to minimize memory leaks in Silverlight
• … and more …

I ran into a problem today where my python script was throwing an exception on me, stating “Permission Denied” on the result file. I was a little confused, and when I tried to open the file myself [note that this was while my test was still running] I was given the alert:

“The process cannot access the file because it is being used by another process”

Turns out that when you open a file [either by File.Open, or by opening a new IsolatedStorageFileStream] you can set a FileShare flag which will indicate if other processes are allowed to read and/or write to the file at the same time.

private static IsolatedStorageFileStream _resultStream;
private static StreamWriter _resultStreamWriter;

private void OpenResultFile()
{
  // Create an isolated storage file  [make sure to set access to read so that other processes can read this file while it's open for writing].
  IsolatedStorageFile resultStore =
    IsolatedStorageFile.GetUserStoreForApplication();

  // Here I open up my file with ReadWrite access for my test app, and then set Read access for all other processes.
  _resultStream = new IsolatedStorageFileStream("TestResults.txt",
    FileMode.Create, FileAccess.ReadWrite, FileShare.Read,
    resultStore);

  _resultStreamWriter = new StreamWriter(_resultStream);
}

I had been using a different overload of the constructor which did NOT set this flag and so when other processes [namely my python script] was trying to read the file when it was open during the test execution, I would get a permission error.

MSDN – IsolatedStorageFileStream Constructor (String, FileMode, FileAccess, FileShare, IsolatedStorageFile)

Turns out I misunderstood exactly how the StreamWriter worked. The data is actually written into a buffer until you explicitly call Flash() or Close(). Because my Close() call was never being called when the app was killed, this data was never actually being flushed from the buffer into the file! Doh!

_resultStreamWriter.WriteLine("Write me now!!!");
_resultStreamWriter.Flush();

MSDN – StreamWriter.Flush Method

System.Reflection.MethodBase thisFunction = System.Reflection.MethodBase.GetCurrentMethod();

string functionName = thisFunction.Name;

The datasource we were using was a custom class of ours, so I therefore had to make it be observable as a collection to allow for this auto updating notification to occur.

Here is how you setup your class to enable it to be part of an observable collection.

// 1: Implement the INotifyPropertyChanged interface on your class.
public class MyCustomClass : INotifyPropertyChanged
{
  // 2: Setup member variables; they must implement get;set.
  private string _myProp;
  public string MyProp
  {
    get { return _myProp; }
    set
    {
       // Check to make sure the value is actually changing.
       // [Thank you to Aaron for pointing this out]
       if (_myProp != value)
       {
         _myProp = value;
         // 3: Call the function which will notify subscribers that a property has changed.
         NotifyPropertyChanged("MyProp");
       }
    }
  } 

  //...  More member variables if you wish

  // 4: Setup the PropertyChangedEventHandler event on your class which will be responsible for telling subscribers that a property has changed; this is required by the INotifyPropertyChanged interface.
  public event PropertyChangedEventHandler PropertyChanged;

  // 5: Define the function [which is called in all your set functions], which is responsible for firing the PropertyChanged event on your class.  Must check for PropertyChanged != null, to make sure that someone is listening before firing the event.
  private void NotifyPropertyChanged(string propertyName)
  {
    if (PropertyChanged != null)
    {
      PropertyChanged(this, new PropertyChangedEventArgs((propertyName)));
    }
  }

  // ...  The rest of your class.
}

// 6: Now you can create observable collections of your class, which can then be bound as data sources for controls.
public class MyCustomCollection: ObservableCollection<MyCustomClass> { }

Then you can use that class as the itemsource [making sure that there are bindings in the XAML for the properties in MyCustomClass] for controls.

Links:
Silverlight.net forum post
MSDN – INotifyPropertyChanged Interface