http://www.scribefire.com/help/firstrun/

Den ser måske ikke ud af meget, men den har et væld af opsætningsmuligheder, og var forbløffende nem at få til at virke. De utallige routere jeg har haft i tidens løb har været enten meget svære at sætte op, eller har vist sig at være helt umulige at arbejde med. Senest en Huawei D100 der ikke har givet mig endet end grå hår!

http://msdn.microsoft.com/en-us/library/cc161164.aspx

The obvious - but wrong way - is to create a static instance of the DataContext somewhere in your business model. The reason this is wrong is that the static variable will remain there for successive calls to your web application. If something goes wrong in one request, for instance if an entity is updated but for some reason the SubmitChanges fails, then this failed object will still be in the DataContext when subsequent (or concurrent) requests to your site occur.

This blog has a nice approach to how the DataContext can be tied to the HttpContext.

http://www.west-wind.com/weblog/posts/246222.aspx

In particular the comment by Richard Deeming using an extension method looks promising.

    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        private void Form1_Load(object sender, EventArgs e)
        {
            // Setup
            turtleBox.Reset();

            KochDelegate kochFunction = null;
            kochFunction = delegate(int angle, int step, int depth)
            {
                if (depth-- < 0) return;

                turtleBox.Turn(angle);
                kochFunction(-angle, step, depth);
                turtleBox.Move(step);
                turtleBox.Turn(-angle);
                kochFunction(angle, step, depth);
                turtleBox.Move(step);
                kochFunction(angle, step, depth);
                turtleBox.Turn(-angle);
                turtleBox.Move(step);
                kochFunction(-angle, step, depth);
                turtleBox.Turn(angle);
            };

            kochFunction(90, 4, 8);
        }
    }

    public class TurtleBox : PictureBox
    {
        private Pen pen = new Pen(Color.Black);
        private Graphics graphics;

        public void Reset()
        {
            Image = new Bitmap(Size.Width, Size.Height);
            graphics = Graphics.FromImage(Image);
            graphics.Clear(Color.White);

            graphics.ResetTransform();
            graphics.ScaleTransform(1, -1);
            graphics.TranslateTransform(0, -Size.Height + 1);
            Turn(-90);
        }

        public void Turn(float angle)
        {
            graphics.RotateTransform(angle);
        }

        public new void Move(int step)
        {
            graphics.DrawLine(pen, 0, 0, 0, step);
            graphics.TranslateTransform(0, step);
        }
    }

    delegate void KochDelegate(int angle, int step, int depth);

Tuddelum

]]> http://web.nafai.org/archives/744/feed http://web.nafai.org/archives/743 http://web.nafai.org/archives/743#comments Tue, 22 Dec 2009 21:35:27 +0000 Thor Asmund http://web.nafai.org/?p=743 For those of you who, like me, have been visiting this site

http://developer.htc.com/adp.html

just to find out that the links to the official 1.6 firmware have “gone fishing”, here is a mirror that actually works.

Instructions for how to install the image can be found on the HTC website above.

Want to root your dev phone, but don’t know which custom ROM to download? Let me recommend CyanoGen. Read more here:

http://www.cyanogenmod.com/about

Happy modding!!

Det er noget man normalt ikke kan i Linq fordi hvis du laver en custom
property, og vil bruge den i en select statement, saa kan Linq ikke
finde ud af at lave den til en expression som kan omsaettes til SQL.

Men jeg har fundet en maade at goere det paa alligevel! Der er vist et
par andre gutter paa nettet der ogsaa har gjort det, men jeg synes
alligevel det var meget sjovt at lave min egen implementering.

Her er et simpelt eksempel. Lad os sige du har en entity class (fx en
klasse som er autogenereret af SQLMetal), vi kan jo kalde den Project.
Den har bla. to properties der hedder Income og Expenses. Lad os sige du
tit laver queries op mod den klasse hvor du gerne vil have Overskuddet
(revenue). Revenue er defineret som Income minus Expenses. Det var nu
oplagt at tilfoeje en ekstra property til Project klassen, saaledes:

public partial class Project
{
  public double Revenue
  {
    get { return Income - Expenses; }
  }
}

Denne property kan godt bruges til fx at populere felterne i en gridview
med, EFTER du har eksekveret din query, men du kan IKKE bruge den
direkte i queryen. Fx kan du ikke skrive:

var ds = from p in myDataContext.projects where p.Revenue > 0 select p;

Det vil komme ud med en fejlmeddelelse om at propertyen Revenue ikke har
nogen SQL-implementation.

Til redning kommer min nye extension method kaldet DynamicWhere. Hvis du
skifter Where ud med DynamicWhere, og skriver din Revenue property en
lille smule op, kan det lade sig goere.

Tricket er, at du skal lade Revenue levere en Expression<Func<>> tilbage
i stedet for et resultat. Men for at queryen skal kunne acceptere
at du skriver fx p.Revenue > xxx saa skal Revenue jo vaere en property
der leverer en double. I stedet laver du saa en statisk skygge-funktion
med et andet navn som leverer en Expression tilbage. Den funktion
associerer du saa med din Revenue funktion via en attribute. Saadan her:

[DynamicProperty(ExpressionPropertyName = "RevenueExpr")]
public double Revenue
{
  get { return RevenueExpr.Compile().Invoke(this); }
}

public static Expression<Func<Project, double>> RevenueExpr
{
  get { return (p => p.Income - p.Expenses); }
}

Jeg har ladet Revenue genbruge den associerede funktion saaledes at man
ikke bliver noed til at skrive p.Income - p.Expenses to gange.

Klik her for at downloade DynamicWhere som DLL projekt.

public static class ExtensionMethods
{
  public static IOrderedQueryable<TSource>
  OrderByDirection<TSource,TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, SortDirection sortDirection)
  {
    return sortDirection == SortDirection.Ascending ?
      source.OrderBy(keySelector) :
      source.OrderByDescending(keySelector);
  }
}

I decided it was smarter if everything was assembled into one Parser class, which you could then instantiate in your program. I wanted to be able to configure it via a grammar also based on objects, build it, and then run the parser every time I wanted to parse a text string.

This is similar to the way the Reges class in C# works. You compile your regex first by instantiating a Regex class and give it the regex pattern, thereafter you can use it to match text strings multiple times.

Read more here…