Eddy Vluggen - Professional Profile

MSDN

Best Practices

• Generics Best Practices[^]
• Event pattern[^]

How To's

• How to remove duplicate rows from a table in SQL Server[^]
• How to: use the Visual Basic "My" namespace in C#[^]
• Walkthrough: Debugging Custom Windows Forms Controls at Design Time[^]

Cheat Sheets

• FamFam Silk icons[^]
• Format Strings[^]
• Visual Representation of SQL Joins[^]
• RegExLib[^]
• MSDN RegEx sheet[^]



• Sql Injection cheat-sheet[^]



• SQL Server 2005 System Views Map[^]
• SQL Server 2008 System Views Map[^]
• SQL Server 2008 R2 System Views Map[^]

Prebuilt code from Microsoft

• Microsoft.SqlServer.ExceptionMessageBox[^]
• ConnectionString Dialog[^]
• A filtered[^] DataGridView
• Sample Browser - by All-In-One Code Framework[^]

Visual Studio Addons

• Productivity Power Tools[^]
• FxCop 10[^] (Downloads the Win7.1 SDK, FxCop 10.0 is in %ProgramFiles%\Microsoft SDKs\Windows\v7.1\Bin\FXCop once you installed the SDK)
• Visual Studio color-settings[^]

Other

• Anonymous Pro[^], a decent font
• Customizing the datagridview to support expanding collapsing ala treegridview[^]
• DataGridView Virtual Mode[^]
• Free Graphics[^] _{(suggested[^] by BillWoodruff in the Free Tools forum)}
• C-Sharp section of Java2s[^]
  
• 101 LINQ samples[^]
  
• Configuring Windows XP to kiosk-mode[^]
  

Security related

• TACO[^], tracking-blocker
 

• MVPS HOSTS file[^]
Easiest way to block a lot of annoying websites. It's a plain text file, goes in a special location to have Windows use it.
 

• Namebench[^]
  DNS Benchmark, also indicates whether key-websites have been hijacked.
Suggested by OriginalGriff in the Free Tools[^] forum

General

• Launchy[^]
Quick-launch app - my current desktop explorer.
 

• SysInternals[^]
Tools
 

• F.lux[^]
dims your PC a bit during night, very pleasant to the eyes.

Coding Tools

• RegEx designer[^]
 

• WMI Code Creator 1.0[^]

• Icon converter[^]
   
  
• MySql table designer[^]
   
  
• Balsamiq Mockups[^]
   
  
• ApiGee[^]
  Try online api's live, from Google to Twitter.
  

Bastard Programmer from Hell

• TreeView with Columns[^]
A TreeView (_{with columns} )

• LogParser DataProvider for ADO.NET[^]
  Example on how to create your own DataProvider.
  

• Awesomium[^]
  Replace that WebBrowser control with Chrome!
  (Or OpenWebKitSharp[^], or the one from Mono[^])
  

Bastard Programmer from Hell

General

• CLR Profiler and How-to[^]
  
• Minidumps and .NET[^]
  

TCP/IP

• HttpWatch[^]
  
• Microsoft Network Monitor[^]
  Hooks into the network-card.
  
• Fiddler[^]
  Complete debugging-proxy with quite some addins.
  

Bastard Programmer from Hell

    if (value != null) return value;
    return defaultvalue;

     if (value != null)
     {
          return value;
     }
     else  // this statement would be superfluous, but it does add a extra visual marker to
     {      // indicate the two different paths that the thread could take, based on the value.
          return defaultvalue;
     }

     return (value == null)
        ? defaultvalue
        : value;

I are Troll

string temp = someObject.SomeValue;
someObject.SomeValue = "Updating, call again later";
try
{
    // do stuff
}
finally
{
    someObject.SomeValue = temp;
}

Imports System
Imports SubSystem
 
Public Class SomeLogger
    Public CategoryName As String = "None Specified"
    Public Sub DoLog(ByVal SomeText As String)
        Console.WriteLine("{0}:    {1}", CategoryName, SomeText)
    End Sub
End Class
 
Public Class Application
    Public Shared Logger As New SomeLogger
 
    Public Shared Sub Main()
                
        Logger.DoLog("Hello World")
 
        Using Temporary.Override(Logger, "CategoryName", "Sub Main")
        
            Logger.DoLog("Hello World")
            
        End Using
 
        Logger.DoLog("Hello World")
        
    End Sub
End Class

using System;
using System.Collections;
using System.Reflection;
using System.IO;
using System.ComponentModel;
 
namespace SubSystem
{
    public class Temporary
    {
        public static IDisposable Override (Object aObject, String aMemberName, Object aScopedValue)
        {
            return init (aMemberName, aObject.GetType (), aObject, aScopedValue);
        }
        public static IDisposable Override (Type aType, String aMemberName, Object aScopedValue)
        {
            return init (aMemberName, aType, null, aScopedValue);
        }
        
        static IDisposable init (String aMemberName, Type aType, Object aObject, Object aScopedValue)
        {
            MemberInfo memberInfo = aType.GetMember (aMemberName)[0];
            
            switch (memberInfo.MemberType) 
            {
                case MemberTypes.Property:
                    return new TemporaryOverrideProperty (
                        aObject == null ? aType : aObject, 
                        (PropertyInfo)memberInfo, 
                        aScopedValue);
    
                case MemberTypes.Field:
                    return new TemporaryOverrideField (
                        aObject == null ? aType : aObject, 
                        (FieldInfo)memberInfo, 
                        aScopedValue);
    
                default:
                    throw new NotSupportedException ();
            }
        }
    }
 

    public class TemporaryOverrideProperty : TemporaryOverride
    {
        PropertyInfo _overridenProperty;
 
        public TemporaryOverrideProperty(Object aObject, PropertyInfo aProperty, Object aScopedValue)
        {
            this._sourceObject = aObject;
            this.init(aProperty, aScopedValue);
        }
        public TemporaryOverrideProperty(Type aSource, PropertyInfo aProperty, Object aScopedValue)
        {
            this._sourceClass = aSource;
            this.init(aProperty, aScopedValue);
        }
 
        ~TemporaryOverrideProperty()
        {
            this.Dispose(false);
        }
 
        void init(PropertyInfo aProperty, Object aScopedValue)
        {
            this._overridenProperty = aProperty;
            this._originalValue = this._overridenProperty.GetValue(this._sourceObject, null);
            this._overridenProperty.SetValue(this._sourceObject, aScopedValue, null);
        }
 
        protected override void Dispose(Boolean disposing)
        {
            if (disposing)
            {
                this._overridenProperty.SetValue(this._sourceObject, this._originalValue, null);
            }
            base.Dispose(disposing);
        }
    }
    public class TemporaryOverrideField : TemporaryOverride
    {
        FieldInfo _overridenField;
 
        public TemporaryOverrideField(Object aObject, FieldInfo aField, Object aScopedValue)
        {
            this._sourceObject = aObject;
            this.init(aField, aScopedValue);
        }
        public TemporaryOverrideField(Type aSource, FieldInfo aField, Object aScopedValue)
        {
            this._sourceClass = aSource;
            this.init(aField, aScopedValue);
        }
 
        ~TemporaryOverrideField()
        {
            this.Dispose(false);
        }
 
        void init(FieldInfo aField, Object aScopedValue)
        {
            this._overridenField = aField;
            this._originalValue = this._overridenField.GetValue(this._sourceObject);
            this._overridenField.SetValue(this._sourceObject, aScopedValue);
        }
 
        protected override void Dispose(Boolean disposing)
        {
            if (disposing)
            {
                this._overridenField.SetValue(this._sourceObject, this._originalValue);
            }
            base.Dispose(disposing);
        }
    }
 
    public class TemporaryOverride : IDisposable
    {
        protected Object _sourceObject;
        protected Type _sourceClass;
        protected Object _originalValue;
        
        protected TemporaryOverride()
        {
        }
 
        #region IDisposable implementation (MSDN adapted version)
        Boolean disposed = false;
 
        public void Dispose()
        {
            this.Dispose(true);
            GC.SuppressFinalize(this);
        }
 
        protected virtual void Dispose(Boolean disposing)
        {
            if (!this.disposed)
            {
                if (disposing)
                {
                    // Dispose managed resources.
                }
 
                // Call the appropriate methods to clean up
                // unmanaged resources here.

                // Note disposing has been done.
                this.disposed = true;
            }
        }
        #endregion
    }
}

I are Troll

Imports System
Imports System.Collections
Imports System.Reflection
Imports System.IO
Imports System.ComponentModel
 
Namespace SubSystem
	Public Class Temporary
		Public Shared Function Override(aObject As [Object], aMemberName As [String], aScopedValue As [Object]) As IDisposable
			Return init(aMemberName, aObject.[GetType](), aObject, aScopedValue)
		End Function
		Public Shared Function Override(aType As Type, aMemberName As [String], aScopedValue As [Object]) As IDisposable
			Return init(aMemberName, aType, Nothing, aScopedValue)
		End Function
 
		Private Shared Function init(aMemberName As [String], aType As Type, aObject As [Object], aScopedValue As [Object]) As IDisposable
			Dim memberInfo As MemberInfo = aType.GetMember(aMemberName)(0)
 
			Select Case memberInfo.MemberType
				Case MemberTypes.[Property]
					Return New TemporaryOverrideProperty(If(aObject Is Nothing, aType, aObject), DirectCast(memberInfo, PropertyInfo), aScopedValue)
 
				Case MemberTypes.Field
					Return New TemporaryOverrideField(If(aObject Is Nothing, aType, aObject), DirectCast(memberInfo, FieldInfo), aScopedValue)
				Case Else
 
					Throw New NotSupportedException()
			End Select
		End Function
	End Class
 

	Public Class TemporaryOverrideProperty
		Inherits TemporaryOverride
		Private _overridenProperty As PropertyInfo
 
		Public Sub New(aObject As [Object], aProperty As PropertyInfo, aScopedValue As [Object])
			Me._sourceObject = aObject
			Me.init(aProperty, aScopedValue)
		End Sub
		Public Sub New(aSource As Type, aProperty As PropertyInfo, aScopedValue As [Object])
			Me._sourceClass = aSource
			Me.init(aProperty, aScopedValue)
		End Sub
 
		Protected Overrides Sub Finalize()
			Try
				Me.Dispose(False)
			Finally
				MyBase.Finalize()
			End Try
		End Sub
 
		Private Sub init(aProperty As PropertyInfo, aScopedValue As [Object])
			Me._overridenProperty = aProperty
			Me._originalValue = Me._overridenProperty.GetValue(Me._sourceObject, Nothing)
			Me._overridenProperty.SetValue(Me._sourceObject, aScopedValue, Nothing)
		End Sub
 
		Protected Overrides Sub Dispose(disposing As [Boolean])
			If disposing Then
				Me._overridenProperty.SetValue(Me._sourceObject, Me._originalValue, Nothing)
			End If
			MyBase.Dispose(disposing)
		End Sub
	End Class
	Public Class TemporaryOverrideField
		Inherits TemporaryOverride
		Private _overridenField As FieldInfo
 
		Public Sub New(aObject As [Object], aField As FieldInfo, aScopedValue As [Object])
			Me._sourceObject = aObject
			Me.init(aField, aScopedValue)
		End Sub
		Public Sub New(aSource As Type, aField As FieldInfo, aScopedValue As [Object])
			Me._sourceClass = aSource
			Me.init(aField, aScopedValue)
		End Sub
 
		Protected Overrides Sub Finalize()
			Try
				Me.Dispose(False)
			Finally
				MyBase.Finalize()
			End Try
		End Sub
 
		Private Sub init(aField As FieldInfo, aScopedValue As [Object])
			Me._overridenField = aField
			Me._originalValue = Me._overridenField.GetValue(Me._sourceObject)
			Me._overridenField.SetValue(Me._sourceObject, aScopedValue)
		End Sub
 
		Protected Overrides Sub Dispose(disposing As [Boolean])
			If disposing Then
				Me._overridenField.SetValue(Me._sourceObject, Me._originalValue)
			End If
			MyBase.Dispose(disposing)
		End Sub
	End Class
 
	Public Class TemporaryOverride
		Implements IDisposable
		Protected _sourceObject As [Object]
		Protected _sourceClass As Type
		Protected _originalValue As [Object]
 
		Protected Sub New()
		End Sub
 
		#Region "IDisposable implementation (MSDN adapted version)"
		Private disposed As [Boolean] = False
 
		Public Sub Dispose() Implements IDisposable.Dispose
			Me.Dispose(True)
			GC.SuppressFinalize(Me)
		End Sub
 
		Protected Overridable Sub Dispose(disposing As [Boolean])
			If Not Me.disposed Then
						' Dispose managed resources.
				If disposing Then
				End If
 
				' Call the appropriate methods to clean up
				' unmanaged resources here.

				' Note disposing has been done.
				Me.disposed = True
			End If
		End Sub
		#End Region
	End Class
End Namespace

Bastard Programmer from Hell

using (new ScopeSupportInitialize(someISupportInitializeControl)
{
 ...
}

someISupportInitializeControl.BeginInit();
...
someISupportInitializeControl.EndInit();

using System;
using System.ComponentModel;
 
public class ScopedSupportInitialize : IDisposable
{
    bool disposed = false;
    ISupportInitialize _owner;
 
    public ScopedSupportInitialize(ISupportInitialize AOwner)
    {
        if (AOwner == null) throw new ArgumentNullException("AOwner");
        _owner = AOwner;
        _owner.BeginInit();
    }
 
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
 
    protected virtual void Dispose(bool disposing)
    {
        if (!this.disposed)
        {
            if (disposing)
            {
                // "Dispose managed resources."
                _owner.EndInit();
            }
 
            // Note disposing has been done.
            disposed = true;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
 
class Program
{
    public delegate object BakeDel(object[] values);
 
    // <summary>
    // ActiveRecord pattern-type BO
    // </summary>
    public class SomeBO
    {
        int someInt;
 
        // <summary>
        // Some property, pointing to some data
        // </summary>
        public int SomeInt
        {
            get
            {
                return someInt;
            }
        }
 
        SomeBO()
        {
        }
 
        public SomeBO(object[] values)
        {
            // this is a simulation, so we'll only fill one
            this.someInt = (int)values[1];
        }
 
        public static object Bake(object[] values)
        {
            return new SomeBO(values);
        }
    }
 
    static void Main(string[] args)
    {
        // some random values for the BO
        object[] vals = new object[3];
        vals[0] = "Hello"; // required variable for all demo-code
        vals[1] = 2;
        vals[2] = "world";
        SomeBO bo; // used to catch the newly created objects

        // number of test-iterations
        int numberOfIterations = 500000;
 
        // Start by testing the speed of instantiating with the "new" keyword
        int theClock = Environment.TickCount;
        for (int i = 0; i < numberOfIterations; i++)
        {
            bo = new SomeBO(vals);
        }
        Console.WriteLine("Native 'new' statement took {0} ms", (Environment.TickCount - theClock));
 
        // Show the Activators' speed as a comparison
        theClock = Environment.TickCount;
        for (int i = 0; i < numberOfIterations; i++)
        {
            bo = (SomeBO)Activator.CreateInstance(typeof(SomeBO), new object[] { vals });
        }
        Console.WriteLine("Activator took {0} ms", (Environment.TickCount - theClock));
        Console.ReadKey();
 
        // Show the speed of reflection as a comparison
        theClock = Environment.TickCount;
        ConstructorInfo ci = typeof(SomeBO).GetConstructor(new Type[] { typeof(object[]) });
        for (int i = 0; i < numberOfIterations; i++)
        {
            bo = (SomeBO)ci.Invoke(new object[] { vals });
        }
        Console.WriteLine("Constructor took {0} ms", (Environment.TickCount - theClock));
        Console.ReadKey();
 
        // Show off, without any IL :)
        theClock = Environment.TickCount;
        Delegate myBakingDelegate = Delegate
            .CreateDelegate(typeof(BakeDel), typeof(SomeBO), "Bake", true);
        if (myBakingDelegate != null)
        {
            BakeDel myLocalBaker = (BakeDel)myBakingDelegate;
            for (int i = 0; i < numberOfIterations; i++)
            {
                bo = (SomeBO)myLocalBaker(vals);
            }
        }
        Console.WriteLine("Bakery took {0} ms", (Environment.TickCount - theClock));
        // Want to know more?
        // http://msdn.microsoft.com/en-us/library/system.delegate.createdelegate.aspx

        Console.ReadKey();
    }
}

Native 'new' statement took 15 ms
Activator took 6459 ms
Constructor took 2902 ms
Bakery took 31 ms

library project1;
 
{$mode objfpc}{$H+}
 
uses
  Classes;
 
procedure DoHelloWorld(var Source: string) stdcall; export;
begin
  Source := 'Hello world :)';
end;
 
exports DoHelloWorld;
 
begin
end.

Imports System.Runtime.InteropServices
Imports System.Text
 
Module Module1
 
    <DllImport("project1.dll", EntryPoint:="DoHelloWorld", CallingConvention:=CallingConvention.StdCall, CharSet:=CharSet.Ansi)> _
    Public Sub DoHelloWorld(ByRef Source As StringBuilder)
    End Sub
 
    Sub Main()
        Dim sb As New StringBuilder()
        DoHelloWorld(sb)
        Console.WriteLine(sb.ToString())
        Console.ReadKey()
    End Sub
 
End Module

Bastard Programmer from Hell

// get a connection-factory
var dbProviderFactory = (System.Data.Common.DbProviderFactory)
        System.Data.Common.DbProviderFactories.GetFactory(
            "System.Data.SqlClient");
            
// create a connection
using (var con = dbProviderFactory.CreateConnection())
{
    // see www.connectionstrings.com for examples
    con.ConnectionString = "Server=.;Trusted_Connection=True;";
 
    // let the connection create a command
    using (var cmd = con.CreateCommand())
    {
        // set the query;
        cmd.CommandText = @"
            SELECT * 
              FROM AdventureWorks.Person.Contact 
             WHERE ModifiedDate > @ModifiedDate";
 
        var modifiedDateParam = cmd.CreateParameter();
        modifiedDateParam.ParameterName = "@ModifiedDate";
        modifiedDateParam.Value = new DateTime(year: 2001, month: 1, day: 1);
        cmd.Parameters.Add(modifiedDateParam);
 
        // open the connection as late as possible
        con.Open();
 
        // open a reader;
        using (var rdr = cmd.ExecuteReader(
            System.Data.CommandBehavior.CloseConnection))
        {
            // while there are records;
            while (rdr.Read())
            {
                Console.WriteLine(String.Format(
                    "{0}, {1}", 
                    rdr["FirstName"],
                    rdr["LastName"]));
            }
        }
    }
}

public static void CreateParamWithValue(
    this System.Data.IDbCommand cmd, 
    string pParamName, 
    object pValue)
{
    System.Data.IDbDataParameter p = cmd.CreateParameter();
    p.ParameterName = pParamName;
    p.Value = pValue;
    cmd.Parameters.Add(p);
}

        cmd.CommandText = @"
            SELECT * 
              FROM AdventureWorks.Person.Contact 
             WHERE ModifiedDate > @ModifiedDate";
 
        cmd.CreateParamWithValue("@ModifiedDate", new DateTime(year: 2001, month: 1, day: 1));
 
        // open the connection as late as possible
        con.Open();

Bastard Programmer from Hell

public partial class MyAboutBox : Form
{
    Assembly _entryAssembly = Assembly.GetEntryAssembly();
 
    T getAttribute<T>() where T: System.Attribute
    {
        object[] attributes = _entryAssembly.GetCustomAttributes(typeof(T), false);
        if (attributes.Length == 0)
        {
            return default(T);
        }
        return ((T)attributes[0]);
    }
 
    public MyAboutBox()
    {
        InitializeComponent();
        this.Text = String.Format("About {0}", AssemblyTitle);
        this.labelProductName.Text = AssemblyProduct;
        this.labelVersion.Text = String.Format("Version {0}", AssemblyVersion);
        this.labelCopyright.Text = AssemblyCopyright;
        this.labelCompanyName.Text = AssemblyCompany;
        this.textBoxDescription.Text = AssemblyDescription;
 
        this.dataGridView1.CellClick += new DataGridViewCellEventHandler(dataGridView1_CellClick);
        foreach (AttributionAttribute aa in protoTyping.fetch())
        {
            int newRowIdx = this.dataGridView1.RowCount;
            this.dataGridView1.RowCount++;
            this.dataGridView1[0, newRowIdx].Value = aa.Author;
            this.dataGridView1[0, newRowIdx].ToolTipText = aa.AuthorLink;
            this.dataGridView1[1, newRowIdx].Value = aa.ContributionTitle;
            this.dataGridView1[1, newRowIdx].ToolTipText = aa.ContributionLink;
        }
    }
 
    void dataGridView1_CellClick(object sender, DataGridViewCellEventArgs e)
    {
        string link = this.dataGridView1[e.ColumnIndex, e.RowIndex].ToolTipText;
        System.Diagnostics.Process.Start(link);
    }
 
    #region Assembly Attribute Accessors
 
    public string AssemblyTitle
    {
        get
        {
            var a = getAttribute<AssemblyTitleAttribute>();
            return a.Title;
        }
    }
 
    public string AssemblyVersion
    {
        get
        {
            return _entryAssembly.GetName().Version.ToString();
        }
    }
 
    public string AssemblyDescription
    {
        get
        {
            var a = getAttribute<AssemblyDescriptionAttribute>();
            return a.Description;
        }
    }
 
    public string AssemblyProduct
    {
        get
        {
            var a = getAttribute<AssemblyProductAttribute>();
            return a.Product;
        }
    }
 
    public string AssemblyCopyright
    {
        get
        {
            var a = getAttribute<AssemblyCopyrightAttribute>();
            return a.Copyright;
        }
    }
 
    public string AssemblyCompany
    {
        get
        {
            var a = getAttribute<AssemblyCompanyAttribute>();
            return a.Company;
        }
    }
    #endregion
}

Bastard Programmer from Hell

using System;
using System.Text;
using System.Collections.Generic;
 
namespace MyBigInt
{
    class Program
 
    {
        public static void Main(string[] args)
        {
            Random rnd = new Random(DateTime.Now.Millisecond);
            long t1 = rnd.Next(0, 99999);
            long t2 = rnd.Next(0, 99999);
 
            MyBigInt bi1 = new MyBigInt(t1.ToString());
            MyBigInt bi2 = new MyBigInt(t2.ToString());
 
            MyBigInt addition = bi1 + bi2;
            MyBigInt multiplication = bi1 * bi2;
 
            Console.WriteLine("Verification: {0} + {1} = {2}", t1, t2, (t1 + t2));
            Console.WriteLine("MyBigInt: {0} + {1} = {2}", bi1, bi2, addition);
            Console.WriteLine(string.Empty);
            Console.WriteLine("Verification: {0} * {1} = {2}", t1, t2, (t1 * t2));
            Console.WriteLine("MyBigInt: {0} * {1} = {2}", bi1, bi2, multiplication);
            Console.WriteLine(string.Empty);
            Console.WriteLine("Any key for a big test :)\n");
            Console.ReadKey(true);
 
            // Generate two huge numbers
            string t3 = string.Empty;
            string t4 = string.Empty;
 
            StringBuilder builder = new StringBuilder(50);
            for (int i = 0; i < 50; i++)
                builder.Append(rnd.Next(0, 9));
            t3 = builder.ToString();
 
            builder = new StringBuilder(50);
            for (int i = 0; i < 50; i++)
                builder.Append(rnd.Next(0, 9));
            t4 = builder.ToString();
 
            MyBigInt bi3 = new MyBigInt(t3);
            MyBigInt bi4 = new MyBigInt(t4);
            Console.WriteLine("Huge addition:\n    {0}\n +  {1}\n = {2}\n", bi3, bi4, bi3 + bi4);
            Console.WriteLine("\nHuge multiplication:\n {0}\n * {1}\n = {2}", bi3, bi4, bi3 * bi4);
            Console.WriteLine(string.Empty);
            Console.WriteLine("Any key closes :)");
            Console.ReadKey(true);
        }
    }
 
    class MyBigInt
    {
        string _value;
 
        public MyBigInt(string value)
        {
            _value = value;
        }
 
        public MyBigInt() : this("0") { }
 
        public static MyBigInt operator +(MyBigInt b1, MyBigInt b2)
        {
            string result = string.Empty;
 
            // If b2 is the larger one, swap 'em;
            // this way the largest is always "in front"
            if (b1.Size < b2.Size)
            {
                MyBigInt b3 = b2;
 
                b2 = b1;
                b1 = b3;
            }
 
            int d1, d2;        // current digit (from b1 and b2)
            string sumD1D2;    // intermediate sum of d1 + d2
            string d3;         // the most-right number of that sum
            int c = 0;         // what needs be carried

            for (int idx1 = 1; idx1 <= b1.Size; idx1++)
            {
                d1 = b1.GetDigit(idx1);
                d2 = b2.GetDigit(idx1);
 
                sumD1D2 = (d1 + d2 + c).ToString();
 
                d3 = sumD1D2.Substring(sumD1D2.Length - 1, 1);
                result = d3 + result;
 
                // carry?               
                if (sumD1D2.Length > 1)
                    c = int.Parse(sumD1D2.Remove(sumD1D2.Length - 1, 1));
                else
                    c = 0;
            }
            return new MyBigInt((c == 0 ? "" : c.ToString()) + result);
        }
 
        public static MyBigInt operator *(MyBigInt b1, MyBigInt b2)
        {
            string result = string.Empty;
 
            // If b2 is the larger one, swap 'em;
            // this way the largest is always "in front"
            if (b1.Size < b2.Size)
            {
                MyBigInt b3 = b2;
 
                b2 = b1;
                b1 = b3;
            }
 
            int d1, d2;        // current digit (from b1 and b2)
            string sumD1D2;    // intermediate sum of d1 + d2
            string d3;         // the most-right number of that sum
            int c = 0;         // what needs be carried 
            List<MyBigInt> sumList = new List<MyBigInt>();
 
            for (int idx2 = 1; idx2 <= b1.Size; idx2++)
            {
                c = 0;
                result = string.Empty;
 
                for (int idx1 = 1; idx1 <= b2.Size; idx1++)
                {
                    d1 = b1.GetDigit(idx2);
                    d2 = b2.GetDigit(idx1);
 
                    sumD1D2 = ((d1 * d2) + c).ToString();
 
                    d3 = sumD1D2.Substring(sumD1D2.Length - 1, 1);
                    result = d3 + result;
 
                    // carry?               
                    if (sumD1D2.Length > 1)
                        c = int.Parse(sumD1D2.Remove(sumD1D2.Length - 1, 1));
                    else
                        c = 0;
                }
                MyBigInt subTtl = new MyBigInt((c == 0 ? "" : c.ToString()) + result + new string('0', idx2 - 1));
 
                sumList.Add(subTtl);
            }
 
            // sum subtotals
            MyBigInt grandTotal = new MyBigInt("0");
 
            foreach (MyBigInt subTotal in sumList)
                grandTotal += subTotal;
 
            return grandTotal;
        }
 
        int GetDigit(int index)
        {
            if (Size - index < 0)
                return 0;
 
            if (Size - index > _value.Length)
                return 0;
 
            return _value[Size - index] - '0';
        }
 
        public int Size
        {
            get { return _value.Length; }
        }
 
        public override string ToString()
        {
            return _value;
        }
    }
}

Bastard Programmer from Hell

DECLARE @TableName AS VARCHAR(4000)
    SET @TableName = <table_name,,'EmployeeTable'>
 
 SELECT COLUMN_NAME
      , DATA_TYPE
      , IS_NULLABLE
      , CHARACTER_MAXIMUM_LENGTH
      , COLUMN_DEFAULT    
      , [value] AS [MS_Description]
   FROM INFORMATION_SCHEMA.COLUMNS is_c,
        ::fn_listextendedproperty
        (NULL, 'user', 'dbo', 'table', @TableName, 'column', default) p
  WHERE TABLE_NAME = @TableName
    AND objname COLLATE Latin1_General_CI_AI = COLUMN_NAME COLLATE Latin1_General_CI_AI
    AND name = 'MS_Description'
  ORDER BY ORDINAL_POSITION ASC;

I are Troll

SELECT * 
  FROM sysobjects
 WHERE xtype='U'
   AND name NOT IN
       (
        SELECT object_name(parent_obj)
          FROM sysobjects
         WHERE xtype = 'PK'
       )

I are Troll

SELECT * 
  FROM sysobjects
 WHERE xtype='U'
   AND name NOT IN
       (
            SELECT object_name(id)
              FROM sysindexes
             WHERE indid = 1
       )
 ORDER BY 1

I are Troll

Public Sub SearchGoogle()
 
    DTE.ItemOperations.Navigate( _
        "http://www.google.com/search?q=" & GetSelectedWord())
 
End Sub
 
Public Sub SearchMsdn()
 
    DTE.ItemOperations.Navigate( _
        "http://www.google.com/search?btnI=I%27m+Feeling+Lucky&hl-en&q=site%3Amsdn.microsoft.com+" & _
        GetSelectedWord())
 
End Sub
 
Private Function GetSelectedWord() As String
 
    Dim selection As TextSelection = DTE.ActiveDocument.Selection()
    If selection.Text <> "" Then
        Return selection.Text
    Else
        DTE.ExecuteCommand("Edit.SelectCurrentWord")
        selection = DTE.ActiveDocument.Selection()
        Return selection.Text
    End If
 
End Function

• Go to the menu Tools / Options
  
• Select "Environment, Keyboard" from the categories
  
• In the box labeled "Show commands containing", type "Googl"
  
• Select the Macro from the list
  
• Click the box labeled "Press shortcut keys", and press F1
  
• Click the "Assign" button (!)
  
• Assign'd Shift-F1 to MSDN.
  

I are Troll

''' Encapsulates the selected text with a Quotes
Public Sub AsQuotedString()
 
    '' Make this atomically undo'able.  Use Try...Finally to ensure Undo
    '' Context is closed.
    Try
        DTE.UndoContext.Open("Macro: AsQuotedString")
 
        ' get current selection
        Dim txtSel As TextSelection = CType(DTE.ActiveDocument.Selection, TextSelection)
 
        ' remove tabs for easy copy/pasting accross applications
        txtSel.Untabify()

        ' define our patterns
        Dim searchPattern As String = "^.#$"
        Dim replacePattern As String = "  ""\(-70,0)"" + _"
 
        ' replace the patterns in the selection
        txtSel.ReplacePattern(searchPattern, replacePattern, vsFindOptions.vsFindOptionsRegularExpression)
 
    Finally
        DTE.UndoContext.Close()
    End Try
End Sub

  SELECT id
       , status
       , max_size
    FROM sys.traces
ORDER BY [id]

  "  SELECT id                                                           " + _
  "       , status                                                       " + _
  "       , max_size                                                     " + _
  "    FROM sys.traces                                                   " + _
  "ORDER BY [id]                                                         " + _