LINQPad Command-Line and Scripting

LINQPad Command-Line and Scripting
Sample usage:

CALL C:\...\LinqPad\lprun.exe "C:\...\Queries\AttachDatabases.linq" DEV

This runs the given linq query. The sample is a "C# Program" and has a "Main" method taking "string[] args" as a paremeter. In this way the "DEV" string at the end of the line is passed as a parameter to the linq program.
Here is the sample linq script:

<Query Kind="Program" />

void Main(string[] args)
{
  string attachFolder = @"C:\Databases\";
  if ((args != null) && (args.Length == 1))
  {
  attachFolder = Path.Combine(attachFolder, args[0]);
  }
  Console.WriteLine("Attaching to databases in \'" + attachFolder + "\'"); 
  Console.WriteLine("");
  var server = @".\";
  var databaseNames = new[] { "XXX", "YYY", "ZZZ", "AAA" };

    using(var connection = new SqlConnection(
   string.Format("Server={0};Database=master;Trusted_Connection=True;", server)))
    {
    connection.Open();
  
    // attach the databases
    foreach(var database in databaseNames)
    {
      var dataFile = Path.Combine(attachFolder, database + "_Data.MDF");
      if (File.Exists(dataFile))
      {
        Console.WriteLine("Attaching {0}", database);
        var attachCommand = connection.CreateCommand();
        attachCommand.CommandText = "sp_attach_db  @dbName, @dataFileName, @logFileName";
        attachCommand.Parameters.AddWithValue("dbName", database);
        attachCommand.Parameters.AddWithValue("dataFileName", dataFile);
        attachCommand.Parameters.AddWithValue("logFileName", 
            Path.Combine(attachFolder, database + "_Log.LDF"));    
        attachCommand.ExecuteNonQuery();
      }
      else
      {
        Console.WriteLine("No data file for {0}", database);
      }
    }
      }
  
    Console.WriteLine("");
    Console.WriteLine("Press any key to continue ...");
    Console.ReadKey(false);
}

If you want the script to hang around a bit so that you can read the error messages then you can add the the following lines to the end

Console.WriteLine("");
Console.WriteLine("Press any key to continue ...");
Console.ReadKey(false);

This keeps the script alive until a key is pressed.

An Animated WPF Gif

The Image control in WPF does not support animated GIF files by default. However, there is a library on codeplex, here, that can be used to do this.
Here is my usage of this library for an animated busy indicator.
In the XAML, first of all create an XML namespace for the library:

xmlns:gif="http://wpfanimatedgif.codeplex.com"

then use it with an image control:

<Image Name="imgBusy" 
       Stretch="UniformToFill" VerticalAlignment="Top" Width="20"  
    gif:ImageBehavior.AnimatedSource="/ScriptRunnerWPF;component/Resources/busyIndicator.gif" 
    gif:ImageBehavior.AutoStart="False" />

In code the animation of the GIF can be controlled:
Start the animation

   
this.imgBusy.Visibility = System.Windows.Visibility.Visible;
ImageAnimationController iac = ImageBehavior.GetAnimationController(this.imgBusy);
if (iac != null)
    iac.Play();

Resume the animation

// Resume the animation (or restart it if it was completed)
ImageAnimationController iac = ImageBehavior.GetAnimationController(this.imgBusy);
if (iac != null)
 iac.Pause();
this.imgBusy.Visibility = System.Windows.Visibility.Hidden;

Using StackTrace

Using StackTrace to show the first 3 lines of a stack trace in the debugger:

StackTrace st = new StackTrace(false);
st.Dump("UpdateScriptRunning Stack Trace", 3);

and the accompanying extension method:

public static class StackTraceExtender
{
  public static void Dump(this StackTrace st, string context, int numFrames)
  {
    Debug.WriteLine(context ?? "");
    string stk = st.ToString();
    string[] wanted = stk.Split(new string[] { "\r\n" }, 
                             StringSplitOptions.RemoveEmptyEntries);
    foreach (string line in wanted.Take(numFrames))
    {
        Debug.WriteLine(line ?? "");
    }
  }
}

WPF Hyperlink Sample

Here are a couple of examples
WPF Application Hyperlink (in this case handle the RequestNavigate)

<TextBlock>Files found using the given <Hyperlink 
Name="hlRules" 
NavigateUri="Rules" 
RequestNavigate="Hyperlink_RequestNavigate">Rules</Hyperlink>:
</TextBlock>

private void HyperlinkRequestNavigate(object sender, RequestNavigateEventArgs e)
{
   // What to do with a hyperlink navigation request?
   // If it is an internet URI this will invoke the default browser
   // Process.Start(new ProcessStartInfo(e.Uri.AbsoluteUri));

   // Otherwise show a dialog or whatever you want
   e.Handled = true;
}

Also check this out this link for a reusable hyperlink navigation routine using dependent properties.

How about using a WPF hyperlink in MVVM. Here is how it is done.
In the XAML add the textblock with the hyperlink and bind it to a command ('AboutCommand' in this case). Note in this sample the text of the hyperlink is also bound to some property 'Version'

 <TextBlock>
    <Hyperlink Command="{Binding AboutCommand}"><TextBlock Text="{Binding Version}" /></Hyperlink>
 </TextBlock>

The command is implemented in the ViewModel

private RelayCommand aboutCommand;

public RelayCommand AboutCommand
{
 get
 {
  return aboutCommand ?? (aboutCommand = new RelayCommand(ExecuteAboutCommand));
 }
}

private void ExecuteAboutCommand()
{
 IAboutDialogService aboutDialogService = ServiceLocator.Current.GetInstance<IAboutDialogService>();
 aboutDialogService.ShowAboutDialog(this.Title);
}

Monotonic Variable

Made this definition up myself. This is effectively a one way variable that starts off in one state and switches to another alternate state. It always starts off in a known state and during the period when it can be accessed by multiple threads it can only be switched to the other alternate state. This has repercussions for thread safe access to the variable with .NET. In certain cases, it can be that none is required. TODO: Explain in more detail.

Generally I use a boolean for my monotonic variable but it is not necessarily a boolean, I have used a reference type in a monotonic manner where the variable has a null reference to begin with, but at some point the reference is assigned.

Code Contract

Normally we use Debug.Assert() for code contracts. To stop the Debug.Assert() statements from activating during unit tests, add the following to te unit tests application config file ("App.Config"):

  <?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <system.diagnostics>
        <assert assertuienabled="false"/> <!-- Disable Debug.Assert() when running unit tests in debug mode. -->
    </system.diagnostics>
</configuration>

Following is a code contract type class that can make code assertions without throwing an Assert dialog during an NUnit test. Also the code contracts will be logged in release. A potential product failure in the field could be traced back to a code contract failure.

using System;
using System.Diagnostics;
using System.Runtime.CompilerServices;

namespace Common.CodeContracts
{
    /// <summary>
    /// A simple code contract class to replace Debug.Assert(). It can be used in release 
    /// and will log code contract failures to the Trace output window.
    /// </summary>
    public static class RuntimeCodeContract
    {
        // Switch on the Debugger.Break when required
        public static bool DebuggerBreakOnFailure { get; set; } = false;

        public static void Requires(bool condition,
                string message,
                [CallerFilePath] string file = "",
                [CallerMemberName] string member = "",
                [CallerLineNumber] int line = 0)
        {
            if (!condition)
            {
                var msg = $"Code contract failure detected: \"{message}\" in member \"{member}\" on line {line} in file \"{file}\"";
                Trace.TraceError(msg);
                if (DebuggerBreakOnFailure)
                {
                    Debugger.Break(); // Use the call stack window to find the invoker location
                }

                //throw new InvalidOperationException(msg);
            }
        }

        public static void RequiresArgument(bool condition,
                string paramName,
                string message = "",
                [CallerFilePath] string file = "",
                [CallerMemberName] string member = "",
                [CallerLineNumber] int line = 0)
        {
            if (!condition)
            {
                var msg = $"Argument requirement failure detected: {message} \"{paramName}\" in member \"{member}\" on line {line} in file \"{file}\"";
                Trace.TraceError(msg);
                if (DebuggerBreakOnFailure)
                {
                    Debugger.Break(); // Use the call stack window to find the invoker location
                }

                //throw new ArgumentException(message, paramName);
            }
        }

        public static void RequiresArgumentNotNull(object parameter,
                string paramName,
                [CallerFilePath] string file = "",
                [CallerMemberName] string member = "",
                [CallerLineNumber] int line = 0)
        {
            if (parameter == null)
            {
                var msg = $"Argument {paramName} was null in member {member} on line {line} in file {file}";
                Trace.TraceError(msg);
                if (DebuggerBreakOnFailure)
                {
                    Debugger.Break(); // Use the call stack window to find the invoker location
                }

                //throw new ArgumentNullException(msg, paramName);
            }
        }

    }
}

It is also a good example of using the compiler attributes "CallerFilePath", "CallerMemberName", and "CallerLineNumber" for diagnostics.

C# Task Object

Task basics
Task and Thread Difference

Here are some notes that I made from these and other blogs:
Task - Specifies some work to be executed asynchronously
ContinueWith - Specifies some work to be executed asynchronously after a task has completed

In computer science terms, a Task is a future or a promise. Basically, a Task "promises" to return you a T, but not immediately

A Thread is one of many ways to fulfill that promise. But not every Task needs a Thread. If the value you are waiting for comes from the filesystem or a database or the network, then there is no need for a thread. The Task might just register a callback to receive the value when the disk is done seeking.

In particular, the Task does not say why it is that it takes such a long time to return the value. It might be that it takes a long time to compute, or it might that it takes a long time to fetch. Only in the former case would you use a Thread to run a Task. (In .NET, threads are freaking expensive, so you generally want to avoid them as much as possible and really only use them if you want to run multiple heavy computations on multiple CPUs.

Tasks can be organised in parent child relationships so that a parent task will wait for its children to complete.

Here is an example of how to start a task with a particular return type and then wait for it to finish

var someTask = Task<int>.Factory.StartNew(() => slowFunc(1, 2));
Task<int32> task = new Task<int32>(n => Sum((Int32)n), 1000);
task.Start(); // Start the task
task.Wait();  // Wait for it to finish

Here is an example of how to cancel a task.

CancellationTokenSource cts = new CancellationTokenSource();
Task<int32> t = new Task<int32>(() => Sum(cts.Token, 1000), cts.Token);
t.Start(); // Start the task
cts.Cancel(); // Cancel the task

Task<int32> t = new Task<int32>(n => Sum((Int32)n), 1000);
       t.Start();
       // notice the use of the Result property
       Task cwt = t.ContinueWith(task => Console.WriteLine(
                       "The sum is: " + task.Result));

They are very easy to use and have a lot of advantages over Threads as follows:

• You can create return types to Tasks as if they are functions.
• You can the "ContinueWith" method, which will wait for the previous task and then start the execution. (Abstracting wait)
• You can use Task.WaitAll and pass an array of tasks so you can wait till all tasks are complete.
• You can attach task to the parent task, thus you can decide whether the parent or the child will exist first.
• You can achieve data parallelism with LINQ queries.
• You can create parallel for and foreach loops
• Very easy to handle exceptions with tasks.
• Most important thing is if the same code is run on single core machine it will just act as a single process without any overhead of threads.

Disadvantage of tasks over threads:

• Not knowing what thread the task is invoked on can be a problem in itself when locking access to data so assume the worst.
• You need .Net 4.0
• Newcomers who have learned operating systems can understand threads better.

Tip:- Always use Task.Factory.StartNew method which is semantically perfect and standard. Actually, under the hood it is a slightly more efficient means to initiate the task as well.

Also can force a task to execute on the GUI thread:

// Get the UI thread's context
var context = TaskScheduler.FromCurrentSynchronizationContext();
...
Task task = Task.Factory.StartNew( () =>
   {
       // Do some work...           
   })
   // Continue on the UI thread, since this lets us update when our
   // "work" completes.
   .ContinueWith(_ => this.label1.Text = "Task Complete!", context);

OR even simpler from within the GUI do

Task task = Task.Factory.StartNew( () =>
   {
       // Do some work...           
   })
   // Continue on the UI thread, since this lets us update when our
   // "work" completes.
   .ContinueWith(_ => this.label1.Text = "Task Complete!",
       TaskScheduler.FromCurrentSynchronizationContext());