Derfor har jeg valgt at lægge et lille testprojekt ud, som kræver minimale tilretninger. Du skal bruge et gyldigt certifikat fra SKAT (som også er aktiveret hos SKAT) og du skal bruge service/server-certifikatet, som ligger på interessent-sitet i Dokumenter->Produktionscertifikater (dmr_virksomhedscertifikat_prod).

Efter installation af begge på klientsiden behøver du kun at ændre thumbprintet i app.config under clientCertificate findValue=”…” til jeres udstedte certifikats thumbprint. Pas på ved kopiering fra certifikatdetaljerne et usynligt tegn i slutningen af thumbprintet kan let snige sig med.

ADVARSEL: flere forskellige sikkerhedsforanstaltninger er slået fra i testprojektet, disse skal naturligvis være slået til i produktion.

public static string ToAlphaNumeric(this string str)
{
    return new string(str.Where(c => char.IsLetterOrDigit(c)).ToArray());
}

public static string ToXml(this object o)
{
    StringWriter sw = new StringWriter();
    XmlWriter xw = XmlWriter.Create(sw);
    DataContractSerializer dcs = new DataContractSerializer(o.GetType());
    dcs.WriteObject(xw, o);
    xw.Close();
    return sw.ToString();
}

public static T FromXmlTo(this string s) where T : class
{
    DataContractSerializer dcs = new DataContractSerializer(typeof(T));

    StringReader sr = new StringReader(s);
    XmlReader xtr = XmlReader.Create(sr);

    return dcs.ReadObject(xtr) as T;
}

Let me here how it works out for you guys..

Add all your dependencies and finally include the code below in your App.xaml.cs or equivalent.. everything else is taken care of.

public App()
{
    AppDomain.CurrentDomain.AssemblyResolve +=new ResolveEventHandler(CurrentDomain_AssemblyResolve);
}

System.Reflection.Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
{
    string dllName = args.Name.Contains(',') ? args.Name.Substring(0, args.Name.IndexOf(',')) : args.Name.Replace(".dll","");

    dllName = dllName.Replace(".", "_");

    if (dllName.EndsWith("_resources")) return null;

    System.Resources.ResourceManager rm = new System.Resources.ResourceManager(GetType().Namespace + ".Properties.Resources", System.Reflection.Assembly.GetExecutingAssembly());

    byte[] bytes = (byte[])rm.GetObject(dllName);

    return System.Reflection.Assembly.Load(bytes);
}

The code is a little bit more complicated than need be. But I wanted to avoid using a named namespace in order to keep the code copy-paste-ready. By the way LINQPad uses a similar method, though Joe Albahari has gone a step further and encrypted his resources.

<object id="Xaml1" data="data:application/x-silverlight-2," type="application/x-silverlight-2"

width="100%" height="100%">

<%––<param name="source" value="ClientBin/SilverlightApp.xap"/>––%>

<%

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" />

This is a small timer class that I have found useful a couple of times.

It takes a job and a timeout in its Run() method, which it executes

after the timeout, unless you call the Run() method again, in which

case it postpones the execution of the job. I have mostly used this

in connection with some type of user input. For instance, doing

something when there has been a sufficient pause in scrolling or typing.

/// <summary>

/// This class can be used to execute a job just once after a specified

/// time since the last of a series of events has fired.

/// For instance, when implementing an Auto-Save feature in a textbox you

/// might want to avoid saving on every keypress event. In this case you can

/// call Run(() => Save(), 5000) in each keypress event. The PostPoningTimer

/// will then make sure that Save() is executed one time when 5 seconds has

/// past since the last keypress event. Any new keypresses will of course

/// repeat the process.

/// </summary>

public class PostponingTimer

{

    private Timer timer;

    private Dispatcher CurrentDispatcher

    {

        get

        {

#if SILVERLIGHT

            return System.Windows.Deployment.Current.Dispatcher;

#else

            return Dispatcher.CurrentDispatcher;

#endif

        }

    }

    private void Execute(Action job, Dispatcher dispatcher)

    {

#if SILVERLIGHT

        dispatcher.BeginInvoke(job);

#else

        dispatcher.Invoke(job);

#endif

    }

    /// <summary>

    /// If you keep calling Run() within timeout, job never gets executed.

    /// Only when you stop calling Run() job will run once after timeout

    /// milliseconds.

    /// <para>Job will run on calling threads dispatcher. If in silverlight

    /// the UI threads dispatcher is used.</para>

    /// </summary>

    /// <param name=”job”></param>

    /// <param name=”timeout”></param>

    public void Run(Action job, int timeout)

    {

        //Make sure the timer from last call is prevented from running.

        if (timer != null) timer.Dispose();

        //When not in SILVERLIGHT the line below makes sure to use the

        //dispatcher of the calling thread.

        //In silverlight the UI thread dispatcher is used.

        Dispatcher dispatcher = CurrentDispatcher;

        timer = new Timer(new TimerCallback((o) =>

            {

                Execute(job, dispatcher);

            }), null, timeout, Timeout.Infinite);

    }

    /// <summary>

    /// If you keep calling Run() within timeout, job never gets executed.

    /// Only when you stop calling Run() job will run once after timeout

    /// milliseconds.

    /// <para>Job will run on the timer’s thread.</para>

    /// </summary>

    /// <param name=”job”></param>

    /// <param name=”timeout”></param>

    public void RunNonUI(Action job, int timeout)

    {

        //Make sure the timer from last call is prevented from running.

        if (timer != null) timer.Dispose();

        timer = new Timer(new TimerCallback((o) =>

            {

                job();

            }), null, timeout, Timeout.Infinite);

    }

    /// <summary>

    /// If you keep calling Run() within timeout, job never gets executed.

    /// Only when you stop calling Run() job will run once after timeout

    /// milliseconds.

    /// <para>Actions will run on calling threads dispatcher. If in

    /// silverlight the UI threads dispatcher is used.</para>

    /// </summary>

    /// <param name=”job”></param>

    /// <param name=”timeout”></param>

    /// <param name=”callback”></param>

    public void Run(Action job, int timeout, Action callback)

    {

        //Make sure the timer from last call is prevented from running.

        if (timer != null) timer.Dispose();

        //When not in SILVERLIGHT the line below makes sure to use the

        //dispatcher of the calling thread.

        //In silverlight the UI thread dispatcher is used.

        Dispatcher dispatcher = CurrentDispatcher;

        timer = new Timer(new TimerCallback((o) =>

            {

                Execute(job + callback, dispatcher);

            }), null, timeout, Timeout.Infinite);

    }

    /// <summary>

    /// If you keep calling Run() within timeout, job never gets executed.

    /// Only when you stop calling Run() job will run once after timeout

    /// milliseconds.

    /// <para>Actions will run on the timer’s thread.</para>

    /// </summary>

    /// <param name=”job”></param>

    /// <param name=”timeout”></param>

    /// <param name=”callback”></param>

    public void RunNonUI(Action job, int timeout, Action callback)

    {

        //Make sure the timer from last call is prevented from running.

        if (timer != null) timer.Dispose();

        timer = new Timer(new TimerCallback((o) =>

            {

                (job + callback)();

            }), null, timeout, Timeout.Infinite);

    }

}

However after pretty much a whole weekend I gave up, having destroyed the MBRs of both disks and set a mixture of both Windows and Linux boot flags on random partitions. I was thinking that it would be another two days before I could enjoy my new laptop fortified with a 160 GB Intel SSD and an extra 2 gigs of ram, but then I stumpled upon this guide and after a very short time the little box was up and running.. with everything. New Windows 7, Drivers, VS, Office, LINQPad and so forth. All the drivers needed magically appeared in Windows Update, maybe not so weird, it sort of is a Microsoft laptop.

If I should do it again, here’s how (or in other words ’my guide to the guide’):

Skip Step 1.

Optionally skip step 2. (I never seem to use restore images anyway)

Do step 3.

In step 4 choose B (Not really a choice) and I highly recommend Method 1. I don’t know why it says time consuming !? AH.. of course when formatting your new drive choose quick format. So in the step 5 of the ’How-to install Windows 7 from an USB stick’ guide  the format line should be:

Format FS=FAT32 QUICK

Please select the RIGHT DRIVE, that is; your new, presumably empty drive. Use an external HDD enclosure/case/thing.

In step 5 (of the main guide)

Ignore all talk about Vista.

Do step 6. For me section B failed because my default printer wasn’t working, so I chose the XPS printer, and it ran fine. All done.

Why allow static methods to disguise themselves as instance methods? Well, on the other hand Linq is awesome.

Another move from Hejlsberg & co. that I’m no fan of, is that it is left to the creator of a class to decide if Equals() should mean that two objects are the same (ReferenceEquals()) or simply equal. And when I want the ‘equal’ functionality, I have to implement it.

So I created this:

An extension method that recursively runs through all public fields and properties and check for value equality at node level. It does not support indexed properties, at least not yet and please notice that this uses the MoreLinq extensions.

Let me know how it works for you..

It solved the same issue I had with LINQPad, I rebuild my assembly and now it could be loaded. I run Windows 7 x64 so I rebuild my assembly to x64.