It is very easy to solve. The easiest way to solve the problem is using BeginInvoke :

Deployment.Current.Dispatcher.BeginInvoke(() =>
{

      textBox1.Text = responseString;

});

Share/Bookmark

If not used properly, LINQ to SQL can also create performance issues. Here are my general LINQ to SQL guidelines when I work in projects:

Use the “using” statement when working with a context

This is mostly a general C# programming guideline but there have been several times when I see programmers missing this step. Here is more information from MSDN.

The using statement allows the programmer to specify when objects that use resources should release them. The object provided to the using statement must implement the IDisposable interface. This interface provides the Dispose method, which should release the object’s resources.

A using statement can be exited either when the end of the using statement is reached or if an exception is thrown and control leaves the statement block before the end of the statement.

Here is an example:

using (NorthwindDataContext context = new NorthwindDataContext())
{
  //do stuff here
}

Compiled queries

To query something with LINQ to SQL there are several “startup” procedures. This procedures are not too bad when queries are not used too often. If the same query is done several times, its heavy and it is the core of the product then it is VERY important to make it a compiled query.

I will not go into too many details about this because there are several posts about the subject:

• LINQ to SQL Compiled Queries
• High Performance LINQ To SQL – Compiled Queries – O/R Mappers – Ecommerce Websites

Use multiple tiny contexts instead of big bulky ones

Contexts are meant to keep track of the objects in the database. By having small contexts with a single purpose then the burden of tracking is lessen and therefore there is less memory consumption.

Do not keep track of object changes in the database unless its needed

There are two good ways to improve the performance of queries that do not involve concurrency issues:

1. Optimistic concurrency  = off
2. Object tracking = off

For object tracking, is super easy to turn off:

context.ObjectTrackingEnabled = false;

Sadly, as  Rick Strahl covers in his blog there are a few things/issues to consider when turning off Object Tracking.

Combine Queries and custom expressions

Combining queries is a good idea when working with databases, just grab what you need and aggregate the data into a POCO model or anonymous type. Finally, if extreme fine control is needed, there is always custom expressions.

Share/Bookmark

After doing a bit of research I came across this. The agents would appear only for seconds under team city and then go down as inactive with the message “Agent has unregistered (will upgrade)”. The culprit was my antivirus. Apparently this is a common issue but I have not seen many people blog about it.

Share/Bookmark

In my opinion, it is an error to try to rate quality of a service as a relation between bugs and release version (this measures how effective are processes). I like to measure quality as a fixed bugs, release version and days to release correlation. This way, we can measure how good is the service by measuring how fast the bugs can be fixed (and properly fixed).

I am not a fan of the even if version 1 sucks, ship it anyway theory but it has some good points. Most of the clients that love my work are happy because any bugs that appeared on the systems have been fixed fast (and remain fixed).

Even google services go down but we all keep using them because google fixes them right away. How can one measure how good is a service? It can be measured by how fast it can respond to change.

Share/Bookmark

Share/Bookmark

Here is a quick Example:

public class DataSource : IDataSource
{
        public DataSource(string URL, string account, string password)
        {
                     //your code here
         }

}

ObjectFactory.Initialize(x =>
{
      x.For<IDataSource>().Use<DataSource>()
           .Ctor<string>("URL").Is(URL)
           .Ctor<string>("account").Is(account)
           .Ctor<string>("password").Is(password)
           ;
}

and you can call it like this:

private IDataSource ds = ObjectFactory.GetInstance<IDataSource>();

There is a huge amount of benefits as I mentioned in my previous post, including saving a lot of typing since all parameters are preconfigured.

Share/Bookmark

Now that with the latest release of VLC that has truly changed. VLC 1.1.0 meets all my expectations. They did an excelent job with the GPU and DSP decoding.

Here is the developers log from GIT: http://git.videolan.org/?p=vlc/vlc-1.1.git;a=tag;h=1.1.0

VLC 1.1.0 - ‘The Luggage’
The first release of the 1.1.x branch of VLC

This is a major release, adding major features, notably:
- GPU and DSP decoding on selected platforms
- New support for codecs, demuxers and muxers
- Lua extensions and Lua content extensions (luaSD)
- Improved interfaces
- Video Output rework
- Removal of lots of modules, rewrite of many
- Improved performances, in CPU, RAM and I/O
- New libVLC and bindings
- New or improved ports on misc platforms
And so many bugs and other features…

Share/Bookmark

There are some other neat features like IntelliTrace and others that are now available.

Here is a link to the latest release: Windows Azure Tools for Microsoft Visual Studio 1.2 (June 2010)

Share/Bookmark

To send custom formated XML use the message envelope and not the string datatype. If the envelope is not used, it will add extra meta content.

Here is how it can be done:

public Message GetMessage(string xml)
{
    XmlDocument x = new XmlDocument();

    //This is very important as it will VALIDATE the XML. Saved my butt a few times.
    x.LoadXml(xml);

    XmlElementBodyWriter writer = new XmlElementBodyWriter(x.DocumentElement);

    Message msg = Message.CreateMessage(MessageVersion.None,
                OperationContext.Current.OutgoingMessageHeaders.Action, writer);

    return msg;
}

public class XmlElementBodyWriter : BodyWriter
{
    XmlElement xmlElement;

    public XmlElementBodyWriter(XmlElement xmlElement)
                : base(true)
    {
         this.xmlElement = xmlElement;
    }

    protected override void OnWriteBodyContents(XmlDictionaryWriter writer)
    {
         xmlElement.WriteTo(writer);
    }
 }

Also a little warning, the string passed in should be formated and already encoded in the format you want. This can make a huge difference specially when internationalization is involved.

Share/Bookmark

One of my goals was to make immutable objects in F# to take advantage of parallelization and automatic compiler optimizations:

type City(Name:string, X: float, Y:float) =

member t.Name = Name

member t.X = X

member t.Y = Y

type NeighborCities(city1:string, city2:string) =

member x.fromCity = city1

member x.toCity = city2

Objects created in this manner in F# are immutable. Even when they are accessed in other projects outside their definition, their members are read-only. This was specially helpful on the distributed traveling salesman problem I built last year.

Share/Bookmark