var a = from address in dc.Addresses
select new {
ID = address.AddressID,
Address1 = address.AddressLine1,
Address2 = address.AddressLine2,
};
var b = from address in dc.Addresses
select new {
ID = address.AddressID,
Address1 = address.AddressLine1,
Address2 = address.AddressLine1, // notice AddressLine1 repeated
};
var q = a.Take(10).Union (b.Take(10));
q.ToArray ();

SqlException: All the queries in a query expression containing a UNION operator must have the same number of expressions in their select lists.

SELECT [t2].[AddressID] AS [ID], [t2].[AddressLine1] AS [Address1], [t2].[AddressLine2] AS [Address2]
FROM (
SELECT TOP (10) [t0].[AddressID], [t0].[AddressLine1], [t0].[AddressLine2]
FROM [Person].[Address] AS [t0]
UNION
SELECT TOP (10) [t1].[AddressID], [t1].[AddressLine1]
FROM [Person].[Address] AS [t1]
) AS [t2]

Notice the third SELECT statement is only selecting two columns instead of the required three.

Please rate and validate this bug at the MSDN Microsoft Product Feedback Center so Microsoft responds with a solution or workaround.

I would like to modify the following LINQ to SQL query:

using (NorthwindContext northwind = new NorthwindContext ()) {
    var q = from row in northwind.Customers
            let orderCount = row.Orders.Count ()
            select new {
                row.ContactName,
                orderCount
            };
}

Which results in the following TSQL:

SELECT [t0].[ContactName], (
    SELECT COUNT(*)
    FROM [dbo].[Orders] AS [t1]
    WHERE [t1].[CustomerID] = [t0].[CustomerID]
    ) AS [orderCount]
FROM [dbo].[Customers] AS [t0]

To:

using (NorthwindContext northwind = new NorthwindContext ()) {
    var q = from row in northwind.Customers.With (
                        TableHint.NoLock, TableHint.Index (0))
            let orderCount = row.Orders.With (
                        TableHint.HoldLock).Count ()
            select new {
                row.ContactName,
                orderCount
            };
}

Which would result in the following TSQL:

SELECT [t0].[ContactName], (
    SELECT COUNT(*)
    FROM [dbo].[Orders] AS [t1] WITH (HOLDLOCK)
    WHERE [t1].[CustomerID] = [t0].[CustomerID]
    ) AS [orderCount]
FROM [dbo].[Customers] AS [t0] WITH (NOLOCK, INDEX(0))

Using:

public static Table<TEntity> With<TEntity> (
    this Table<TEntity> table,
    params TableHint[] args) where TEntity : class {

    //TODO: implement
    return table;
}
public static EntitySet<TEntity> With<TEntity> (
    this EntitySet<TEntity> entitySet,
    params TableHint[] args) where TEntity : class {

    //TODO: implement
    return entitySet;
}

And

public class TableHint {
    //TODO: implement
    public static TableHint NoLock;
    public static TableHint HoldLock;
    public static TableHint Index (int id) {
        return null;
    }
    public static TableHint Index (string name) {
        return null;
    }
}

Using some type of LINQ to SQL extensibility, other than this one. Any ideas?

Please comment on this question over at StackOverflow.com

This project focuses on the .NET server-side architecture, initially providing a HttpListener implementation (for a custom host communicating with HTTP.SYS directly) and may eventually provide a ASP.NET implementation as well. The library will simplify the implementation of common message patterns such as pushing latest data as well as sync. Example code for multiple client-side javascript implementations will also be provided.

[Column(Storage="_ProductLine", DbType="NChar(2)")]
public string ProductLine
{
  get
  {
    return this._ProductLine;
  }
  set
  {
    if ((this._ProductLine != value)) {
      this.OnProductLineChanging(value);
      this.SendPropertyChanging();
      this._ProductLine = value;
      this.SendPropertyChanged("ProductLine");
      this.OnProductLineChanged();
    }
  }
}

The odd code involves the SendPropertyChanging() method call. This method call should pass the name of the property, just like the SendPropertyChanged() method call, according to the documentation. Another interesting detail: The OnProductLineChanging and OnProductLineChanged partial method calls are out of order:

1. Call OnProductLineChanging() partial method
2. Raise PropertyChanging event, but don’t tell which property is changing – send an empty string instead
3. Set the property’s field’s value to the specified new value
4. Raise PropertyChanged event and specify which property is changing
5. Call OnProductLineChanged() partial method

Why is the PropertyChanged event raised before calling the OnProductLineChanged partial method?

All classes created by LINQ to SQL add the following protected methods:

protected virtual void SendPropertyChanging() {
  if ((this.PropertyChanging != null)) {
    this.PropertyChanging(this, emptyChangingEventArgs);
  }
}
protected virtual void SendPropertyChanged(String propertyName) {
  if ((this.PropertyChanged != null)) {
    this.PropertyChanged(this,
        new PropertyChangedEventArgs(propertyName));
  }
}

Again, what’s odd about this code is how the SendPropertyChanging() method does not have a property name parameter and sends a emptyChangingEventArgs field reference to the PropertyChanging event rather than creating a new instance of the EventArgs like the SendPropertyChanged() method call does. By creating a new instance of the EventArgs in SendPropertyChanged, it’s able to pass the property name in the constructor (like the documentation says it should).

Here is the field that is passed to all invocations of the event:

private static PropertyChangingEventArgs emptyChangingEventArgs =
  new PropertyChangingEventArgs(String.Empty);

As you can see from this constructor, the property that is changing is an empty string. Given the fact that this is a private field and should not be modified by extension methods, it’s odd that this field is not static readonly.

My guess is that the code is generated incorrectly to account for a data-binding or allocation problem. I’ve come to this conclusion by the emptyChangingEventArgs field – it reduces the object instance creation in half for each property change when there are event consumers for the changing event. The big disadvantage for event consumers is that they doesn’t know which property is changing on an object instance.

One alternative is to use PLINQO, which creates the properties correctly.

UPDATE: I have found that this has already been reported. Unfortunately, Microsoft has closed this bug and said it was by design, even though the generated code does not follow Microsoft’s documentation for the PropertyChangingEventArgs class.

public static IQueryable<TSource> WhereIn<TSource, TKey> (
        this IQueryable<TSource> source1,
        Expression<Func<TSource, TKey>> keySelector,
        IEnumerable<TKey> source2) {
    if (null == source1)
        throw new ArgumentNullException ("source1");
    if (null == keySelector)
        throw new ArgumentNullException ("keySelector");
    if (null == source2)
        throw new ArgumentNullException ("source2");
    Expression where = null;
    foreach (TKey value in source2) {
        Expression equal = Expression.Equal (
                    keySelector.Body,
                    Expression.Constant (value, typeof (TKey))
                    );
        if (null == where)
            where = equal;
        else
            where = Expression.OrElse (where, equal);
    }
    return source1.Where<TSource> (
        Expression.Lambda<Func<TSource, bool>> (
            where, keySelector.Parameters));
}

An example of the usage:

var q = (from u in db.Users
    where u.LastLogin > new DateTime (2007, 5, 1)
    orderby u.LastLogin descending
    select new { u.FirstName, u.LastName, u.UserName, u.LastLogin }
    ).WhereIn (u => u.UserName, new string[] { "A", "B", "C" });

A day later, I found the right way that will actually generate “WHERE X IN (…)” in LINQ to SQL thanks to Mark Blomsma.

To reproduce this bug, create this stored procedure and run SqlMetal against it:
CREATE PROCEDURE [dbo].[ThisProcedureWillCauseSqlMetalToCrash] AS
BEGIN
SET NOCOUNT ON;
SELECT 1 [A], 2 [ ], 3 [C]
END

Applies to:

• Visual Studio 2008 RTM
• Microsoft Windows SDK v6.0A

Please rate and validate this problem at the MSDN Microsoft Product Feedback Center so Microsoft responds with a solution or workaround.

In Microsoft. Practices. EnterpriseLibrary. Logging. TraceListeners. EntLibLoggingProxyTraceListener, comment out
properties.Add(TraceEventCacheKey, eventCache); // line 66 & 146 (fix for SerializationException)
In Microsoft. Practices. EnterpriseLibrary. Logging. TraceListeners. MsmqTraceListener, change queueMessage.Label = messageLabel;
to queueMessage.Label = string.IsNullOrEmpty (messageLabel) ? string.Empty : messageLabel; // line 153 (fix for ArgumentNullException)
In LoggingDatabase.sql, change [Title] [nvarchar](256) NOT NULL,
to [Title] [nvarchar](256) NULL,

When a ClickOnce application is updating on startup, please display a wait cursor, or some indication to the user that the application is loading - the progress bar currently disappears after the new version is downloaded. On older computers, the time between the progress bar dissapearing and the application loading can take 30-50 seconds…

HttpWebRequest request = …;
request.CachePolicy =
  new System.Net.Cache.HttpRequestCachePolicy (
    System.Net.Cache.HttpRequestCacheLevel.Default);
request.GetResponse ();

GetResponse () throws a WebException: “The request was aborted: The request was canceled.” Inner exception shows that the private method CheckCacheUpdateOnResponse () of System.Net.HttpWebRequest encounters a NullReferenceException.

A “workaround” would involve loading the user’s profile. For example, if the application pool custom identity is DOMAIN\MyWebApp, log in to the server as MyWebApp. The error goes away – until the profile is unloaded.

This problem does not occur when the web application is using the default application pool identity, NetworkService, because I believe that profile is already loaded by default.

Another bug report is somewhat similar to this but only manifests after a few thousand requests. These are probably symptoms of a much larger bug (or design flaw – http request caching is currently implemented through IE’s cache).

Update: Microsoft has reproduced this bug and will be addressing it in a future release.

The message parameter is first and paramName is second for one of ArgumentException’s constructors.
public ArgumentException(string message, string paramName);

These exceptions inherit ArgumentException:

• In one of ArgumentOutOfRangeException’s constructors, paramName is first and message is second.
  public ArgumentOutOfRangeException(string paramName, string message);
• In one of InvalidEnumArgumentException’s constructors, argumentName is used to represent the same value as paramName. This is an overload that doesn’t include the message parameter, which is normal.public InvalidEnumArgumentException(string argumentName, int invalidValue, Type enumClass);
• In one of DuplicateWaitObjectException’s constructors, parameterName is first, represents the same value as paramName, and message is second.
  public DuplicateWaitObjectException(string parameterName, string message);

Questions:

1. Why are there three names used to represent paramName?
2. Why was the parameter order changed in the child classes?

The service is hosted in IIS, and the web.config is configured as:
<system.serviceModel><services>
<service name="Namespace.TypeName" …
Filename.svc is configured:
<% @ServiceHost Service="Namespace.TypeName " %>
When you browse to the filename.svc file:

TypeName Service
You have created a service.
To test this service, you will need to create a client and use it to call the service.

After looking through the documentation, I found that the service name is configured through the ServiceBehavior attribute:
[ServiceBehavior (Name = "The name of the service")]
public class TypeName {…

Hope this helps…

Synchronization Services lets you synchronize data from disparate sources over two-tier, N-tier, and service-based architectures. Instead of only replicating a database and its schema, the Synchronization Services application programming interface (API) provides a set of components to synchronize data between data services and a local store. Applications are increasingly used on mobile clients, such as portable computers and devices, that do not have a consistent or reliable network connection to a central server. It is important for these applications to work against a local copy of data on the client. Equally important is the need to synchronize the local copy of the data with a central server when a network connection is available. The Synchronization Services API is modeled after the ADO.NET data access APIs and gives you an intuitive way to synchronize data. It makes building applications for occasionally connected environments a logical extension of building applications where you can depend on a consistent network connection.

This looks like a great addition to ADO.NET for the .NET 3.5 release. Be sure to check out Rafik’s blog on synchronization services…

I found that this architecture easily supports the removal of all behavior*:

public static void ClearEventHandlerList (Component component) {
    if (component == null)
        throw new ArgumentNullException ("component");
    FieldInfo fieldInfo = (typeof (Component)).GetField ("events",
        BindingFlags.Instance |
        BindingFlags.NonPublic |
        BindingFlags.DeclaredOnly |
        BindingFlags.ExactBinding);
    EventHandlerList currentList =
        fieldInfo.GetValue (component) as EventHandlerList;
    if (currentList != null)
        currentList.Dispose ();
    fieldInfo.SetValue (component, null);
}

For example, a security component could easily remove a control’s behavior* when the user does not have permission. Keep in mind that this is not a substitute for declarative or imperative security checks - other methods can continued to refer to the control’s state or subscribe to its events in the future.

Other benefits include the ability for a security component to use a ToolTip to notify the user of access denied (ToolTips do not function on disabled controls).

button.Click += new System.EventHandler (this.button_Click);
// the button_Click method is called when the button is clicked
...
ClearEventHandlerList (button);
// button does not have a click event subscriber anymore
// (button_Click is no longer called when the button is clicked)

* behavior as defined by event subscriptions where the event accessor implementation uses the EventHandlerList class.

1. Run cmd.exe with administrative privileges
2. Run the following command:
   shutdown /s /t 600
3. Abort the shutdown with this command:
   shutdown /a

Notification of an aborted system shutdown in Beta 2 had a strange title:

Luckily, Microsoft has enhanced the title in RC1, but there is still room for improvement:

Check out this clip from The Daily Show where John Hodgman explains the technical implementation of the Internet and why we need network neutrality:

Digital cameras have a clock and store the capture date and time as metadata in the JPEG image. The clock must be set correctly for images from multiple sources to be organized in the order in which they were taken.

To have all of the pictures of the birthday party together in chronological order, I had to:

• Separate all pictures taken by a specific camera by folder
• Perform the following for each folder:
  • Estimate the date and time of one of the pictures taken
  • Use jhead, a EXIF command-line utility, David found to fix the metadata
    • Use the –da switch to specify the actual and recorded date and time
    • Execute for all JPEG images (*.JPG)
  • Import the pictures in to Aperture.
  • Compare the pictures to others with the correct date and time.
  • If the images don’t line up correctly, delete them, and start over again with a better estimate.

Time Machine is a truly good idea: It helps you automatically back up everything on your system and restore earlier versions of files at any time. (1)

It’s much more than just files - it’s data. Time Machine includes an API for applications to backup/restore data – such as contacts or browser favorites. Unlike other backup software or OS features, you can individually restore a contact deleted in the past using the software that created the contact, Address Book, and Time Machine. This is not possible with any technology Microsoft has shipped or has announced for Vista. The API can be used by applications to support incremental backups of data inside of the application’s data store – instead of the entire data store (think Personal Folders.pst).

But this was a great idea over three years ago when Microsoft first added it to Windows Server 2003 as Volume Shadow Copy (VSC, or “Previous Versions” to end users). (1)

Snapshots are a more advanced technology (2) that are technically better than a file copy for point in time backups of an entire disk volume. So, Microsoft added a better technology (than file copy) to Windows Server 2003 & Windows Vista. Time Machine uses a “file system event notification system” (2) to determine which files to copy the files to the backup device. Since snapshots require source volume, and the idea is to backup to an external volume or network location, snapshots (on their own) are not a viable solution.

That’s why Microsoft is shipping both Previous Versions and Windows Backup as part of Vista. A user can rely on Windows Backup to restore all of the applications and data or selected file types. Previous Versions represents a convenient way to restore files by right-clicking the file, selecting properties, and browsing through the list of every snapshot taken of the file. Windows Backup is slow, performs full and incremental backups, and will notify the user when they should create a new, full backup. Previous Versions is fast and data is stored on the source volume along with the actual data without annoying user prompts. Windows Backup is a traditional backup application, and traditionally, most people do not use these applications.

(1) Apple Mac OS X Leopard Preview: Who’s the Copycat Now?
(2) Time Machine and the future of the file system

email2face.com | digg story

• Syntax error in manifest or policy file file name on line 2. The manifest file root element must be assembly.
• The application failed to launch because of an invalid manifest.
• Generate Activation Context failed for file name.Manifest. Reference error message: The operation completed successfully.

You may also receive this message box:

• The operation could not be completed. This application has failed to start because the application configuration is incorrect. Reinstalling the application may fix this problem.

If you were using a beta version of Visual Studio 2005, you may have the configuration namespace, http://schemas.microsoft.com/.NetConfiguration/v2.0, referenced in your app.config. This is not supported by SxS, so you application will fail to load when you create an application manifest, or attempt to use ClickOnce.

Please rate and validate this problem at the MSDN Microsoft Product Feedback Center so Microsoft responds with a solution or workaround.

• The manifest may not be valid or the file could not be opened
• Manifest XML signature is not valid
• The profile for the user is a temporary profile

Please rate and validate this problem at the MSDN Microsoft Product Feedback Center so Microsoft responds with a solution or workaround.

Iterators and Efficient Use of the Thread Pool

int? x = 5;
int? y = null;
// since x is not null, (x ?? 0) returns 5.
Assert.AreEqual(5, (x ?? 0));
// since y is null, (y ?? 0) returns 0.
Assert.AreEqual(0, (y ?? 0));

The operator also works with reference types:

// table can be null
public static int Fill(DataTable table)
{
  // if table is null, _defaultDataTable is used instead
  foreach(DataRow dataRow in table.Rows ?? _defaultDataTable.Rows)
  {
    // do work
  }
  return 0;
}

Video presentation from Tech·Ed 2005: An In-Depth Look at C# 2.0

I had a scheduling problem with the 2003 PDC – you could imagine my surprise when I found out it conflicted with my honeymoon. I realized that I had to push my employer (for two years) to budget for training for the next PDC. My work paid off – In January of 2005, my supervisor informed me that I was going to the PDC. Unfortunately, in May, I accepted a position with another company.

read more | digg story

For proxy servers & faster performance, I recommend downloading Wget to automatically retrieve RSS feeds from outside the company to a locally run web server. Wget can retrieve remote RSS feeds through proxies that require authentication. You can create a batch file that runs Wget against all external RSS feeds, and configure it to run as a scheduled task. Then, point msxsl to the local web server’s cached copy to generate the DWP file. In this configuration, WSS-RSS will retrieve the RSS feed from your local web server for display in SharePoint. You should also lower SharePoint’s cache time of WSS-RSS because it is retrieving the feed locally. Because the latency and bandwidth favor your local network, performance will be greatly improved. I will provide a downloadable sample shortly.

System.Net.WebException: The underlying connection was closed: Could not establish trust relationship with remote server.

This usually happens on a client calling a secure web service with a user generated certificate. Did you write this code to solve the problem?

public class TerribleCertificatePolicy : System.Net.ICertificatePolicy {
  public bool CheckValidationResult(ServicePoint sp, X509Certificate cert, WebRequest req, int problem) {
      return true;
    }
  }
...
System.Net.ServicePointManager.CertificatePolicy = new TerribleCertificatePolicy();

So now you’ve made this HTTPS transport security insecure and susceptible to a man-in-the-middle attack. If you compare this with an Internet Explorer dialog box, it’s basically clicking yes to every security alert. If you search for ICertificatePolicy on the web, you’ll find many results showing the same insecure code (including Microsoft support). Two popular options to maintain HTTPS security are to either import the web server’s certificate or root certificate to the client machine’s trusted certificates store, or verify the public key byte[] returned from the certificate.GetPublicKey() method. If you verify the issuer name, you’re wasting CPU cycles.

To demonstrate how easy it is for someone to view your HTTPS conversation between your client and server, download Cain. With this software, you target your client’s IP Address with ARP poisoning, and essentially become the man-in-the-middle. So Cain’s pretty cool in the sense it will download the public key from the real server and create another public/private key that looks just like the real one (other than the fact that it has a different public key). After it does this, your client establishes a HTTPS connection with Cain – and it has no idea. The DNS, the IP Address; everything looks great. Cain has a HTTPS connection with the real server – and the fun begins. All that’s required are a couple of clicks in Cain. If this wasn’t a security issue it would be really funny since you’ve established a secure connection with the hacker! Did you realize these tools are so sophisticated?

Click here for an example (at the bottom of the post) that shows how to securely verify a server’s certificate.

XSL converts RSS to a native Windows SharePoint Services DataViewWebPart DWP file.

• No binaries, installation or server configuration necessary.
• Supports RSS versions 0.90, 0.91, 0.92, 1.0, and 2.0.
• Supports the Atom Syndication Format 0.3.
• Supports Microsoft’s Channel Definition Format.
• Html output is similar to the links list summary view.
• Title, Description, and DetailLink come from the RSS channel element.
• RSS 2.0’s time to live attribute or RSS 1.0’s syndication module are used to determine cache time for the webpart.
• Please email me any suggestions/bugs/fixes.
• Absolutely free: MIT License.

Known issues:

• Does not support feeds requiring authentication.
• Sometimes doesn’t support feeds containing accents.

The service has moved to SharePointRSS.com.

I disagree with that statement. I find that games against slightly less skilled opponents are the most fun. On Wednesday, I had some great scores and my level went from 4 to 5 after the first game on Saturday. Then I started to play against opponents whose level was between 5 and 10! It was really bad, and my level went back to 4. How depressing.

char[] charsA = new char[] { 'a', 'b', 'c', 'a' };
char[] charsB = new char[] { 'a', 'c', 'b', 'a' };
Assert.IsTrue(Collection.Equals(charsA, charsB, false));
int[] intA = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5 };
int[] intB = new int[] { 9, 8, 7, 6, 5, 5, 4, 4, 3, 3, 2, 2, 1, 1, 0, 0 };
Assert.IsTrue(Collection.Equals(intA, intB, false));
ArrayList arrayListA = new ArrayList();
ArrayList arrayListB = new ArrayList();
arrayListA.Add(charsA); // Adds the array as an item
arrayListB.AddRange(charsB); // Adds the items from the array
arrayListA.Add(intA);
arrayListB.AddRange(intB);
Assert.IsTrue(arrayListA.Count == 2);
Assert.IsTrue(arrayListB.Count == 20);
Assert.IsTrue(Collection.Equals(arrayListA, arrayListB, false));

I had to create the RelaxComparer so I could add all types to two SortedList collections that are built by the algorithm to determine equality. The SortedList objects are also used to keep track of the number of times each item appears in each collection.

I merged the CollectionEquals method I created earlier together with this new algorithm to a new Collection class that can test both types of collection equality:

(more…)

I created the following class to use instead of the default Comparer class (which just calls the CompareTo method of each object implementing IComparable) to perform sorting (and other comparison related algorithms) with objects of different types.

/// <summary>
/// Compares two objects for equivalence, where objects of different
/// types are compared by their string representations.
/// </summary>
public class RelaxComparer : IComparer
{
  public int Compare(object x, object y)
  {
    Type typeX = x.GetType(), typeY = y.GetType();
    /* IComparable.CompareTo(object obj) The parameter, obj, must be
     * the same type as the class or value type that implements this
     * interface; otherwise, an ArgumentException is thrown */
    if (typeX == typeY && typeof(IComparable).IsAssignableFrom(typeX))
      return ((IComparable)x).CompareTo(y);
    else
      return x.ToString().CompareTo(y.ToString()); // use strings
  }
}

So now you can add strings, chars, ints in any order and sort the items with the sort method of ArrayList:

char[] chars = new char[] { 'a', 'd', 'c', 'b' };
int[] ints = new int[] { 4, 3, 1, 2, 0 };
char[] CHARS = new char[] { 'B', 'C', 'D', 'A' };

ArrayList arrayList = new ArrayList();

foreach(char x in chars)
  arrayList.Add(x);

foreach(int x in ints)
  arrayList.Add(x);

foreach(char x in CHARS)
  arrayList.Add(x);

arrayList.Sort(new RelaxComparer());

foreach(object o in arrayList)
  Console.Write(string.Format("{0} ", o));

// output: 0 1 2 3 4 A B C D a b c d

DataTable dataTable = null;
using(IDbConnection dbConnection = (IDbConnection)database.Unwrap())
{
  dbConnection.Open();
  using (IDbCommand dbCommand = dbConnection.CreateCommand())
  {
    dbCommand.CommandType = CommandType.Text;
    dbCommand.CommandText = "SELECT * FROM SomeLargeTable;";
    using (IDataReader dataReader =
    dbCommand.ExecuteReader(CommandBehavior.KeyInfo))
    {
      dataTable = dataReader.GetSchemaTable();
      dataReader.Close();
    }
  }
  dbConnection.Close();
}
// look at table schema stored in dataTable

Results in the following SQL executed on Sql Server:

SET FMTONLY OFF; SET NO_BROWSETABLE ON;
SELECT * FROM SomeLargeTable; SET NO_BROWSETABLE OFF;

If you add “| CommandBehavior.SchemaOnly” to the ExecuteReader method call:

SET FMTONLY OFF; SET NO_BROWSETABLE ON; SET FMTONLY ON;
SELECT * FROM SomeLargeTable; SET FMTONLY OFF; SET NO_BROWSETABLE OFF;

In the SqlDataReader implementation, the CommandBehavior.SchemaOnly sets FMTONLY ON which, according to the Transact-SQL Reference, “No rows are processed or sent to the client as a result of the request when SET FMTONLY is turned ON.” With (CommandBehavior.KeyInfo | CommandBehavior.SchemaOnly), I had a significant preformance increase - makes perfect sense since returning 100,000,000 rows to retrieve table schema is inefficent, to say the least.

You may be able to save thousands of dollars in interest payments and reduce the term of your loan by several years, or just enjoy the ability to have your payment drafts occur when you receive your paycheck.

In reality, they take my money every week but hold it until they’ve accumulated enough to pay the monthly bill. So the fact I made weekly payments had no effect on the loan. In the event I paid more than what was due for the month, it went against the principal, consequently reducing the interest and term of the loan.

While other lenders may offer similar plans, they also charge significant up-front fees, which can add up to hundreds of dollars. With PayPlan/52, you pay nothing to enroll, and a nominal fee of $1.00 for each weekly transaction.

I can pay additional principal when I make my monthly payment, consequently reducing the interest and term of the loan. So where’s the benefit of spending an additional $52/year for this PayPlan service?

There are two types of serialization in .NET: System.Runtime.Serialization and System.Xml.Serialization. Runtime serialization uses the serializable attribute while XML serialization does not. Since ASP.NET uses XML serialization, the attribute was irrelevant.

The error I received was “System.Net.IPAddress cannot be serialized because it does not have a default public constructor.” One of the requirements of the XmlSerializer is that the class it is trying to serialize must have a default public constructor.

object a = 1;

object b = 1;

Assert.IsFalse (a == b);

Object a doesn’t equal object b since boxing a as object created once instance, and boxing b created another. Since == is a “reference type equality operator”, it will only compare the references.

Using any of these methods works fine:

Assert.IsTrue (a.Equals (b));

Assert.IsTrue (((int)a).Equals (b));

Assert.IsTrue (Object.Equals (a, b));

Assert.IsTrue ((int)a == (int)b);

When passing objects around, the simple solution is to use the Equals() method as it may perform value equality if the object overrides Equals(). So, value equality is somewhat easy to accomplish for individual objects, but you run into this problem again with collections:

Assert.IsFalse (

    new string[] { “abc”, “def” }.Equals (

    new string[] { “abc”, “def” }));

Assert.IsFalse (new int[] { 1, 2, 3 }.Equals (new int[] { 1, 2, 3 }));

Assert.IsFalse (

    new object[] { 4, “stuff”, DateTime.Parse (“1/1/2004 1:00 AM”) }.Equals (

    new object[] { 4, “stuff”, DateTime.Parse (“January 1, 2004 01:00″) }));

There is only reference equality with ArrayList since Object.Equals() is inherited not overridden.

Assert.IsFalse (

    new System.Collections.ArrayList (new int[] { 1, 2, 3 }) == 

    new System.Collections.ArrayList (new int[] { 1, 2, 3 }));

Assert.IsFalse (

    new System.Collections.ArrayList (new int[] { 1, 2, 3 }).Equals (

    new System.Collections.ArrayList (new int[] { 1, 2, 3 })));

Here’s my solution to perform value equality for collections. And now:

Assert.IsTrue (Collection.Equals (

    new System.Collections.ArrayList (new int[] { 1, 2, 3 }), 

    new System.Collections.ArrayList (new int[] { 1, 2, 3 }), true));

Assert.IsTrue (Collection.Equals (

    new int[] { 1, 2, 3 }, new System.Collections.ArrayList (

    new int[] { 1, 2, 3 }), true));

Assert.IsTrue (Collection.Equals (

    new object[] { 1, 2, 3 }, 

    new int[] { 1, 2, 3 }), true);

Assert.IsTrue (Collection.Equals (

    new object[] { 4, “stuff”, DateTime.Parse (“1/1/2004 1:00 AM”) }, 

    new object[] { 4, “stuff”, DateTime.Parse (“January 1, 2004 01:00″) }), true);

Here’s a real world example:

/// <summary>Always accepts the public key hardcoded in the byte array as a valid certificate.</summary>

public sealed class AcceptTrustedCertificate : ICertificatePolicy {

    public bool CheckValidationResult (

        ServicePoint srvPoint,

        X509Certificate certificate,

        WebRequest request,

        int certificateProblem) {

        //TODO: verify certificateProblem is an acceptable value

        // return true if certificate returned is equal to the certificate’s public key

        return Collection.Equals (

            certificate.GetPublicKey (),

            new byte[] { 48, 130, 1, 10, 2, 130, 1, 1, 0, 206, 214, 212 }, true);

    }

}

From my experience with RSS.NET, I believe that this code is useless. These formats will eventually evolve and new formats will arise. These libraries should evolve to solve a different problem: generating libraries that read and write specific XML formats.

Armed with a XML schema and an object mapping XML file, this new type of library should be able to generate libraries themselves whose purpose is to read and write to a specific XML file format. After this assembly is produced, developers can use this “strongly typed” object and its formatReader and formatWriter objects to read and write documents. Since this library would use code generation, developers would code this library against the XML schema standard, resulting in generic code that could be applied to any XML format.

The result could be RSS, ATOM, and OPML objects who can read and write their respective formats a piece at a time (by using a stream) or, all at once. They would be schema compliant, optimized for each specific version, and most importantly, extremely easy to use by the end developer.

Through his network of websites, George provides you with access to a variety of resources, including source code, download areas, communication forms, and product information (collectively “Content”). This Content, including any updates, enhancements, new features, and/or the addition of new Content, as subject to the TOU.

This website supports a preliminary release of a weblog that may be changed substantially prior to final public release. This website is provided for informational purposes only and George makes no warranties, either express or implied, in this website. Information in this website, including all postings, URL and other Internet Web site references, is subject to change without notice. The entire risk of the use or the results from the use of this website remains with the user. Unless otherwise noted, the example companies, organizations, products, domain names, e-mail addresses, logos, people, places, and events depicted herein are fictitious, and no association with any real company, organization, product, domain name, e-mail address, logo, person, place, or event is intended or should be inferred. Complying with all applicable copyright laws is the responsibility of the user. Without limiting the rights under copyright, no part of this website may be reproduced, stored in or introduced into a retrieval system, or transmitted in any form or by any means (electronic, mechanical, photocopying, recording, or otherwise), or for any purpose, without the express written permission of George.

George may have patents, patent applications, trademarks, copyrights, or other intellectual property rights covering subject matter in this website. Except as expressly provided in any written license agreement from George, the furnishing of this website does not give you any license to these patents, trademarks, copyrights, or other intellectual property.

The opinions expressed herein do not represent George’s personal opinions or his employer’s, family, or friends’ view in any way.

Source code

Source code (software) that is available on this website is licensed under this license:

Copyright © 2003-2007, George Tsiokos. All Rights Reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

• Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
• Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
• Neither the name of this website nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.