Tom Hines (writinThatCode.com)

Calling An ASMX Web Service From Different Languages

Tom Hines — Mon, 08 Mar 2010 04:07:25 GMT

[Switch to "Elastic Layout" to see this properly.]

I get a lot of mileage using Web Services inside an intranet. I sometimes need to cross operating systems and languages to take advantage of pre-written services. One issue I've run across is the need to find the correct syntax in different languages that will generate a correct result. Some implementations are really easy and others require some delicate, precision work in order for them to respond correctly. Once written, however, they are consistent in their performance.

In this example, I've taken a minor Web Service (function: GetWeather(String City)) that returns random weather information when given a city. This is just for fun and to test parameters on Web Service calls. The service is at:

http://www.deeptraining.com/webservices/weather.asmx

This page has no HTML test page built for it, so your actual call will need to be the entity performing the test.

When a successful call is given, the responses are in the range of: Rain, Sunny, Partly Cloudy, Cloudy, etc.
Here is a sample result of three runs from the Ruby version:

If anyone wants to create the Scala and/or Python versions (before I do), I will gladly post them here.

FYI: Perl and Java were the most difficult / cumbersome and C++ was the easiest.

Here is the PHP version:

<?php

function doWebService()
{
       ########################################################################
       # Do some SOAP / Call a Web Service
       $client = new SoapClient("http://www.deeptraining.com/webservices/weather.asmx?WSDL");
       $strWeather = $client->GetWeather(array('City' => 'Murfreesboro'))->GetWeatherResult;
       echo $strWeather . "\nDone";
}

doWebService();
?>

Here is the Ruby version:

require 'soap/wsdlDriver' # Include the soap driver
require 'SuppressWarning' # Suppress the soap unused param warning

################################################################################
# Call to a web service on the Internet (passing a parameter)
def   doWebService()
   # Instantiate a soap driver for the given service and NameSpace
   # Call the return from the driver creation, pass it a parameter and
   # Append "Done" to the end of that
   # of course, this is now unReadable...
   puts (
      soap = suppress_warning {
         SOAP::WSDLDriverFactory.new(
            'http://www.deeptraining.com/webservices/weather.asmx?WSDL'
            ).create_rpc_driver
         }
      ).getWeather({'City' => 'Murfreesboro'}).getWeatherResult+"\nDone"
end

doWebService()

Here is the Perl version:

## WORKS as of 03/06/2010
use strict;
use SOAP::Lite;

###############################################################################
sub doWebService()
{
   my $FUNCTION      = 'GetWeather';
   my $strParamName = 'City';
   my $strParamValue = 'Murfreesboro';
   my $strNamespace = 'http://litwinconsulting.com/webservices';

   #############################################################################
   # Set the value of ACTION to the value you need passed in the
   # SOAPAction header
   # Init the WebService
   my $soap = SOAP::Lite
      ->proxy('http://www.deeptraining.com/webservices/weather.asmx')
      ->on_action(sub { return "$strNamespace/$FUNCTION"; } )
      ->ns("$strNamespace/");

   #####################
   # Call the WebService
   my $resp = $soap->call(
      SOAP::Data->name("$FUNCTION")->attr({xmlns => "$strNamespace/"}),
      SOAP::Data->name($strParamName => $strParamValue)
      );

   #########################################################
   # Since the result comes back as a string, just print it.
   return $resp->result();
}

print &doWebService();
print "\nDone\n";

Here is the Java version:

import java.util.*;
import java.io.*;
import java.net.URLConnection;
import java.net.MalformedURLException;

import org.apache.axis.client.Call;
import org.apache.axis.client.Service;
import org.apache.axis.encoding.XMLType;
import javax.xml.namespace.QName;
import javax.xml.rpc.NamespaceConstants;
import javax.xml.rpc.ParameterMode;
import java.net.URL;

public class doWebService
{
      public      static void doWebServiceCall()
      {
            try
            {
                  ////////////////////////////////////////////////////////////////////
                  // Responds the same with or without the ?WSDL
                  String      strEndPoint       = "http://www.deeptraining.com/webservices/weather.asmx";
                  String      strSoapAction     = "http://litwinconsulting.com/webservices/GetWeather";
                  String      strSchemaURL      = "http://litwinconsulting.com/webservices/";
                  String      strParamName1     = "City";
                  String      strParameterVal1= "Murfreesboro";
                  String      strFunctionName   = "GetWeather";

                  //Call      call   = (Call) new Service().createCall();//Works
                  Call call   = new Call(strEndPoint);//Works same

                  ////////////////////////////////////////////////////////////////////
                  // first parameter in QName seemingly takes ANYTHING
                  call.setOperationName(new QName(strSchemaURL, strFunctionName));

                  ////////////////////////////////////////////////////////////////////
                  // Set the name of the parameter and the return type
                  call.setReturnType(XMLType.XSD_STRING);
                  call.addParameter(new QName(strSchemaURL,strParamName1), XMLType.XSD_STRING, ParameterMode.IN);
                  //
                  ////////////////////////////////////////////////////////////////////
                  // Catch the result and print it
                  // Parameter count is now ONE (1).
                  call.setSOAPActionURI(strSoapAction);//Yes Necessary
                  String      strResult = (String) call.invoke(new Object[] {strParameterVal1});
                  System.out.println("Result='" + strResult + "'");
            }
            catch (Exception e)
            {
                  e.printStackTrace();
                  System.err.println(e.toString());
            }
      }

      public static     void main(String[] args)
      {
            ////////////////////////////////////////////////////////////////////////
            //    6 Call a Web service (with parameters)
            doWebServiceCall();
      }
}

Here is the C++ version (once the WS is added to the project):

// doWebService_CPP.h
#pragma once
using namespace System;
using namespace WS_WEATHER;

namespace doWebService_CPP {

       public ref class CDoWebService_CPP
       {
       public:
              static void DoWebService(void)
              {
                     Weather^ svcWeather = gcnew Weather();
                     Console::WriteLine(svcWeather->GetWeather("Murfreesboro") + "\nDone");
              }
       };
}

Here is the VB version (once the WS is added to the project):

Public Class CDoWebService_VB
   Public Shared Sub DoWebService()
      Dim svcWeather As New WS_WEATHER.Weather()
      Console.WriteLine(svcWeather.GetWeather("Murfreesboro") & Chr(10) & "Done")
   End Sub
End Class

Here is the C# version (once the WS is added to the project):

using System;
using doWebService_CS.WS_WEATHER;

namespace doWebService_CS
{
   public class CDoWebService_CS
   {
      public static void DoWebService()
      {
         Weather svcWeather = new Weather();
         Console.WriteLine(svcWeather.GetWeather("Murfreesboro") + "\nDone");
      }
   }
}

Here is the PowerShell version (borrowing from the C# version):

################################################################################
# Instead of attempting to dynamically reference a WebService, I leveraged the
# existing connection through a DLL created in C# in an earlier example.
# This example shows the loading of the DLL
# how to call a static method with PowerShell
[void][Reflection.Assembly]::LoadFile(
"c:\science\managed\doWebService_CS\bin\Debug\doWebService_CS.dll")

[doWebService_CS.CDoWebService_CS]::DoWebService()

## For a more thorough look at PowerShell and WebServices, check: http://poshcode.org/538

Cross-language Extension Method Calling

Tom Hines — Fri, 05 Mar 2010 23:22:11 GMT

Extension methods are a concise way of binding functions to particular types.

In my last post, I showed how Extension methods can be created in the .NET 2.0 environment.
In this post, I discuss calling the extensions from other languages.

Most of the differences I find between the Dot Net languages are mainly syntax. The declaration of Extensions is no exception. There is, however, a distinct difference with the framework accepting excensions made with C++ that differs from C# and VB.

When calling the C++ extension from C#, the compiler will SOMETIMES say there is no definition for DoCPP with the error:
'string' does not contain a definition for 'DoCPP' and no extension method 'DoCPP' accepting a first argument of type 'string' could be found (are you missing a using directive or an assembly reference?)

If I recompile, the error goes away.

The strangest problem with calling the C++ extension from C# is that I first must make SOME type of reference to the class BEFORE using the extension or it will not be recognized at all. So, if I first call the DoCPP() as a static method, the extension works fine later. If I make a dummy instantiation of the class, it works. If I have no forward reference of the class, I get the same error as before and recompiling does not fix it. It seems as if this none of this is supposed to work across the languages.

I have made a few work-arounds to get the examples to compile and run.

Note the following examples:

Extension in C#

using System;

namespace Extension_CS
{
   public static class CExtension_CS
   { //in C#, the "this" keyword is the key.
      public static void DoCS(this string str)
      {
         Console.WriteLine("CS\t{0:G}\tCS", str);
      }
   }
}

Extension in C++

/****************************************************************************\
* Here is the C++ implementation. It is the least elegant and most quirky,
* but it works.
\****************************************************************************/
#pragma once
using namespace System;
using namespace System::Runtime::CompilerServices;     //<-Essential
// Reference: System.Core.dll //<- Essential

namespace Extension_CPP {
       public ref class CExtension_CPP
       {
       public:
              [Extension] // or [ExtensionAttribute] /* either works */
              static void DoCPP(String^ str)
              {
                     Console::WriteLine("C++\t{0:G}\tC++", str);
              }
       };
}

Extension in VB

' Here is the VB implementation. This is not as elegant as the C#, but it's
' functional.
Imports System.Runtime.CompilerServices
'
Public Module modExtension_VB 'Extension methods can be defined only in modules.
   <Extension()> _
      Public Sub DoVB(ByVal str As String)
      Console.WriteLine("VB" & Chr(9) & "{0:G}" & Chr(9) & "VB", str)
   End Sub
End Module

Calling program in C#

/******************************************************************************\
* Main calling program
* Intellisense and VS2008 complain about the CPP implementation, but with a
* little duct-tape, it works just fine.
\******************************************************************************/
using System;
using Extension_CPP;
using Extension_CS;
using Extension_VB; // vitual namespace

namespace TestExtensions
{
   public static class CTestExtensions
   {
      /**********************************************************************\
       * For some reason, this needs a direct reference into the C++ version
       * even though it does nothing than add a null reference.
       * The constructor provides the fake usage to please the compiler.
      \**********************************************************************/
      private static CExtension_CPP x = null;   // <-DUCT_TAPE!
      static CTestExtensions()
      {
         // Fake usage to stop compiler from complaining
         if (null != x) {} // <-DUCT_TAPE
      }

      static void Main(string[] args)
      {
         string strData = "from C#";
         strData.DoCPP();
         strData.DoCS();
         strData.DoVB();
      }
   }
}

Calling program in VB

Imports Extension_CPP
Imports Extension_CS
Imports Extension_VB
Imports System.Runtime.CompilerServices

Module TestExtensions_VB
   <Extension()> _
      Public Sub DoCPP(ByVal str As String)
      'Framework does not treat this as an extension, so use the static
      CExtension_CPP.DoCPP(str)
   End Sub

   Sub Main()
      Dim strData As String = "from VB"
      strData.DoCS()
      strData.DoVB()
      strData.DoCPP() 'fake
   End Sub
End Module

Calling program in C++

// TestExtensions_CPP.cpp : main project file.

#include "stdafx.h"

using namespace System;
using namespace Extension_CPP;
using namespace Extension_CS;
using namespace Extension_VB;

void main(void)
{
       /*******************************************************\
     * Extension methods are called like static methods
     * when called from C++. There may be a difference in
     * syntax when calling the VB extension as VB Extensions
     * are embedded in Modules instead of classes
       \*******************************************************/
    String^ strData = "from C++";
    CExtension_CPP::DoCPP(strData);
    CExtension_CS::DoCS(strData);
    modExtension_VB::DoVB(strData); //since Extensions go in Modules
}

Extension Methods in Dot Net 2.0

Tom Hines — Fri, 05 Mar 2010 18:57:45 GMT

Not that anyone would still need this, but in case you have a situation where the code MUST be .NET 2.0 compliant and you want to use a cool feature like Extension methods, there is a way.

I saw this article when looking for ways to create extension methods in C++, C# and VB:

http://msdn.microsoft.com/en-us/magazine/cc163317.aspx

The author shows a simple way to declare/define the ExtensionAttribute so it's available to 2.0 .NET code.

Please read the article to learn about the when and why and use the content below to learn HOW.
In the next post, I'll demonstrate cross-language calling of extension methods.

Here is a version of it in C#

First, here's the project showing there's no VOODOO included:

using System;

namespace System.Runtime.CompilerServices
{
   [
      AttributeUsage(
         AttributeTargets.Assembly
         | AttributeTargets.Class
         | AttributeTargets.Method,
      AllowMultiple = false, Inherited = false)
   ]
   class ExtensionAttribute : Attribute{}
}

namespace TestTwoDotExtensions
{
   public static class Program
   {
      public static void DoThingCS(this string str)
      {
         Console.WriteLine("2.0\t{0:G}\t2.0", str);
      }

      static void Main(string[] args)
      {
         "asdf".DoThingCS();
      }
   }
}

Here is the C++ version:

// TestTwoDotExtensions_CPP.h
#pragma once
using namespace System;

namespace System {
       namespace Runtime {
              namespace CompilerServices {
              [
                     AttributeUsage(
                           AttributeTargets::Assembly
                            | AttributeTargets::Class
                           | AttributeTargets::Method,
                     AllowMultiple = false, Inherited = false)
              ]
              public ref class ExtensionAttribute : Attribute{};
              }
       }
}

using namespace System::Runtime::CompilerServices;

namespace TestTwoDotExtensions_CPP {

public ref class CTestTwoDotExtensions_CPP
{
   public:
           [ExtensionAttribute] // or [Extension]
           static void DoThingCPP(String^ str)
   {
      Console::WriteLine("2.0\t{0:G}\t2.0", str);
   }
};
}

Ruby-Like "times" method #ruby #csharp #linq #vb #cpp

Tom Hines — Wed, 03 Mar 2010 20:07:05 GMT

Before I noticed how many other people had blogged about this same thing, I wrote an implementation of a "times" (integer extension) method -- the kind you'd find when coding in Ruby that is passed a block of code that it executes (n) times.

Consider the following (in Ruby):

#####################################
# prints:
#   Ruby was here
#   Ruby was here

2.times {
   printf("Ruby was here\n")
}

#####################################
# prints:
#   Ruby was here 0
#   Ruby was here 1

2.times {|i|
   printf("Ruby was here %d\n", i)
}

The closest to this I got in C# was:

public static void DoTest1()
{
   /******************************************************\
    * This technique is the actual goal of this exercise
   \******************************************************/
   2.times(DoWriteLine);   // <-GOAL!
   2.times(DoWriteLineAndNum);
   // or
   2.times(i => Console.WriteLine("CSharp was here"));
   2.times(i => Console.WriteLine("CSharp was here: " + i));
}

The C# class I created (with two extension methods) looks like this:

using System;
using System.Linq;

namespace RubyLike
{
   public static class CRubyLike
   {

      /// <summary>
      /// Performs an action i number of times
      /// </summary>
      /// <param name="i">number of times to repeat</param>
      /// <param name="action">action to be repeated</param>
      public static void times(this int i, Action action)
      {
         Enumerable.Range(0, i).ToList().ForEach(n => action());
      }

      /// <summary>
      /// Performs an action i number of times passing the
      /// repeat target as a parameter.
      /// Allowing: 5.times(n => Console.Write("hey"));
      /// </summary>
      /// <param name="i">number of times to repeat</param>
      /// <param name="action">action to be repeated</param>
      public static void times(this int i, Action<int> action)
      {
         int iCount=0;
         Enumerable.Range(0, i).ToList().ForEach(n => action(iCount++));
      }
   }
}

Here is the C++ Example

// TestRubyLike_CPP.h
#pragma once

using namespace System;
using namespace RubyLike;

namespace TestRubyLike_CPP {

       public ref class CTestRubyLike_CPP
       {
       private:
              static void DoWriteLine(void)
                     {Console::WriteLine("C++ was here");}

              static void DoWriteLine(int i)
                     {Console::WriteLine("C++ was here "+ i.ToString());}

       public:
              static void DoTest(void)
              {
                     CRubyLike::times(2, gcnew Action(DoWriteLine));
                     CRubyLike::times(2, gcnew Action<int>(DoWriteLine));
                     CRubyLike::times(2, gcnew Action(Console::WriteLine));//blank/blank
                     CRubyLike::times(2, gcnew Action<int>(Console::WriteLine));//0/1
              }
       };
}

Here is the VB Example:

Imports System
Imports RubyLike

Public Class CTestRubyLike_VB
   Private Shared Sub DoWriteLine()
      Console.WriteLine("VB was here")
   End Sub

   Private Shared Sub DoWriteLine(ByVal i As Integer)
      Console.WriteLine("VB was here: " & i)
   End Sub

   Public Shared Sub DoTest1()
      Dim iVal As Integer = 2
      iVal.times(New Action(AddressOf DoWriteLine))
      iVal.times(New Action(Of Integer)(AddressOf DoWriteLine))
      iVal.times(New Action(AddressOf Console.WriteLine)) 'blank/blank
      iVal.times(New Action(Of Integer)(AddressOf Console.WriteLine)) '2/2
   End Sub

   Public Shared Sub DoTest2()
      CRubyLike.times(2, New Action(AddressOf DoWriteLine))
      CRubyLike.times(2, New Action(Of Integer)(AddressOf DoWriteLine))
      CRubyLike.times(2, New Action(AddressOf Console.WriteLine)) 'blank/blank
      CRubyLike.times(2, New Action(Of Integer)(AddressOf Console.WriteLine)) '2/2
   End Sub
End Class

Here is the C# Example:

using System;
using RubyLike;

namespace TestRubyLike_CS
{
   public static class CTestRubyLike_CS
   {
      private static void DoWriteLine()
      {
         Console.WriteLine("CSharp was here");
      }

      private static void DoWriteLineAndNum(int i)
      {
         Console.WriteLine("CSharp was here: " + i);
      }

      public static void DoTest1()
      {
         /******************************************************\
          * This technique is the actual goal of this exercise
         \******************************************************/
         2.times(DoWriteLine);   // <-GOAL!
         2.times(DoWriteLineAndNum);

         // or
         2.times(i => Console.WriteLine("CSharp was here"));
         2.times(i => Console.WriteLine("CSharp was here: " + i));
      }

      public static void DoTest2()
     {
         CRubyLike.times(2, DoWriteLine);
         CRubyLike.times(2, DoWriteLineAndNum);
         CRubyLike.times(2, (Action)Console.WriteLine);//blank/blank
         CRubyLike.times(2, (Action<int>)Console.WriteLine);//2/2
      }
   }
}

Here is a calling program for these (in C#)

using System;
using TestRubyLike_CS;
using TestRubyLike_CPP;
using TestRubyLike_VB;

namespace TestRubyLike
{
   public static class CTestRubyLike
   {
      static void Main(string[] args)
      {
         ///////////////////////////////
         // Make calls on extension methods
         Console.WriteLine("C# Example 1: ---------------------");
         CTestRubyLike_CS.DoTest1();

         // or
         ///////////////////////////////////
         // Make calls on static methods
         Console.WriteLine("C# Example 2: ---------------------");
         CTestRubyLike_CS.DoTest2();

         ///////////////////////
         // Make calls from C++
         Console.WriteLine("C++ Example: ----------------------");
         CTestRubyLike_CPP.DoTest();

         /////////////////////
         // Make calls from VB
         Console.WriteLine("VB Example 1: ---------------------");
         CTestRubyLike_VB.DoTest1();

         //or
         Console.WriteLine("VB Example 2: ---------------------");
         CTestRubyLike_VB.DoTest2();
      }
   }
}

And, of course, the output:

Enumerable::ToList() - C++ Missing From MSDN

Tom Hines — Mon, 22 Feb 2010 22:30:45 GMT

I would like to make one of these entries for every example I don't find on MSDN.
I'm not sure if the intention is to ignore C++ or if this was just expected to be too hard, too easy or too ugly for developers to grasp.

I have submitted this as Community Content on MSDN, also.

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

Here is the missing example for Enumerable::ToList();

#include "stdafx.h"

using namespace System;
using namespace System::Collections::Generic;
using namespace System::Linq;

int GetLength(String^ str)
{
       return str->Length;
}

void main(void)
{
       array<String^>^ fruits = { "apple", "passionfruit", "banana", "mango",
                      "orange", "blueberry", "grape", "strawberry" };

       List<int>^ lengths =
              Enumerable::ToList(
                     Enumerable::Select(
                           gcnew List<String^>(fruits),
                                  gcnew Func<String^, int>(GetLength)
                           )
                     );

       for each(int length in lengths)
       {
              Console::WriteLine(length);
       }

/*
This code produces the following output:

5
12
6
5
6
9
5
10
*/
}

Linq Distinct and Custom Object Sort

Tom Hines — Tue, 16 Feb 2010 02:50:58 GMT

The main purpose of this post is to show what's required in the main 3 .net languages for filtering and sorting.
I decided to put these two problems together because they presented themselves to me simultaneously .

There are many instances where I need to Sort custom objects and many instances where I need to filter out duplicates from a list of custom objects.

For filtering (Distinct), the effect happens with the framework finds unique values for the object.
For the Sort, the default comparer will not work on most custom objects, so some specifics need to be included.

Here are the two actions that need to be done to ensure success:

Create the object and override the ToString(), Equals() and GetHashCode() methods.
- I base the "uniqueness" on the value inside ToString() because it's easier
than other techniques.
For sorting, create a custom "Compare" class based on the IComparer interface
- this class must contain a Compare method.

...and now for the example:
Some of the sorting code is commented out because it is only needed once. I could have simply called the same method from each example, but I want to show it in each language.

I chose a very simple Person class containing two strings and an int.

First, here is the object:

namespace PersonObj
{
   public class CPerson
   {
      public string strFirstName {get; set;}
      public string strLastName { get; set; }
      public int intAge { get; set; }

      public CPerson()
      {
         strFirstName = "";
         strLastName = "";
         intAge = 0;
      }

      public CPerson(string strFirstName, string strLastName, int intAge)
      {
         this.strFirstName = strFirstName;
         this.strLastName = strLastName;
         this.intAge = intAge;
    }

      //1. Override the ToString (your choice on uniqueness)
      public override string ToString()
      { // Used to create a unique vision of the object
         return
            strLastName.Trim() + ", " + //comma-space
            strFirstName.Trim() + ", " +//comma-space
            intAge.ToString();//suitable for printing
      }

      //2. Override the Equals so the comparison is done on the String
      public override bool Equals(object obj)
      { // essential
         return obj.ToString().Equals(this.ToString());
      }

      //3. Override the GetHashCode, so the internals can find uniqueness
      public override int GetHashCode()
      { // steal the HashCode from the ToString()
         return this.ToString().GetHashCode();
      }
   }
}

////////////////////////////////////////////////////////////
// Here's the main calling program.
using System;
using System.Collections.Generic;
using System.Linq;
//
using PersonObj;
using LinqDistinctCS;
using LinqDistinctCPP;
using LinqDistinctVB;
//
namespace LinqDistinct
{
   class Program
   {
      public static List<CPerson> lstPeople = new List<CPerson>()
      {
         new CPerson(){strLastName="Page", strFirstName="Neal", intAge=46},
         new CPerson(){strLastName="Page", strFirstName="Neal", intAge=46},
         new CPerson(){strLastName="Griffith", strFirstName="Del", intAge=45},
         new CPerson(){strLastName="Page", strFirstName="Susan", intAge=42},
         new CPerson(){strLastName="Griffith", strFirstName="Marie", intAge=34},
         new CPerson(){strLastName="Page", strFirstName="Marti", intAge=8},
         new CPerson(){strLastName="Page", strFirstName="Neal", intAge=6} //Junior
      };

      static void Main(string[] args)
      {
         Console.WriteLine("\n--- Before Distinct ---");
         lstPeople.ForEach(p => Console.WriteLine(p));

         Console.WriteLine("\n--- With Distinct CPP and Sort ---");
         CLinqDistinctCPP.TestDistinct(lstPeople);

         Console.WriteLine("\n--- With Distinct CSharp ---");
         CLinqDistinctCS.TestDistinct(lstPeople);

         Console.WriteLine("\n--- With Distinct VB ---");
         CLinqDistinctVB.TestDistinct(lstPeople);
      }
   }
}

C++ Example

// LinqDistinctCPP.h
#pragma once
using namespace System;
using namespace System::Collections::Generic;
using namespace System::Linq;
using namespace PersonObj;
//
public ref class CComparePerson : IComparer<CPerson^>
{
public:
       /*************************************************\
       ** Even though I'm comparing strings, the method
       ** must take CPerson parameters and do the string
       ** comparison underneath.
       \*************************************************/
       virtual int Compare(CPerson^ p1, CPerson^ p2)
       {
              return p1->ToString()->CompareTo(p2->ToString());
       }
};

//
namespace LinqDistinctCPP {

       public ref class CLinqDistinctCPP
       {
       public:
              //
          static void DoPrint(CPerson^ p)
          {
                     Console::WriteLine(p);
          }
          //
              static void TestDistinct(List<CPerson^>^ lstPeople)
              {
                     // lstPeople->Sort(); ** Throws InvalidOperationException **
                     // The delegate must be in a separate class
                     lstPeople->Sort(gcnew CComparePerson()); // ** Good **

                     // Note how C++ uses the Extension methods as static methods
                     Enumerable::ToList(
                           Enumerable::Distinct(lstPeople))
                           ->ForEach(gcnew Action<CPerson^>(DoPrint));
              }
       };
}

C# Example

using System;
using System.Collections.Generic;
using System.Linq;
using PersonObj;

namespace LinqDistinctCS
{
   /*
   public class CComparePerson : IComparer<CPerson>
   {
      virtual public int Compare(CPerson p1, CPerson p2)
          {
                 return p1.ToString().CompareTo(p2.ToString());
          }
   }
   */
   public class CLinqDistinctCS
   {
      public static void TestDistinct(List<CPerson> lstPeople)
      {
         // lstPeople.Sort(); ** Throws InvalidOperationException **
         // lstPeople.Sort(new CComparePerson()); // ** Good **
         // ...or...
         // lstPeople.Sort((p1, p2) => p1.ToString().CompareTo(p2.ToString()));
         lstPeople.Distinct().ToList().ForEach(p => Console.WriteLine(p));
      }
   }
}

VB Example

' Here's the VB Example
Imports System
Imports System.Collections.Generic
Imports System.Linq
Imports PersonObj
'
'Public Class CComparePerson
'Implements IComparer(Of CPerson)
'
'Public Function Compare(ByVal p1 As CPerson, _
'    ByVal p2 As CPerson) As Integer _
'Implements IComparer(Of CPerson).Compare
'   Return p1.ToString().CompareTo(p2.ToString())
'End Function
'End Class

Public Class CLinqDistinctVB
   Public Shared Sub TestDistinct(ByVal lstPeople As List(Of CPerson))
      'lstPeople.Sort() ** Throws InvalidOperationException **
      'lstPeople.Sort(New CComparePerson) ' ** Good **
      ' ...or...
      'lstPeople.Sort(Function(p1, p2) p1.ToString().CompareTo(p2.ToString()))
      lstPeople.Distinct().ToList().ForEach(AddressOf Console.WriteLine)
   End Sub
End Class

Here's the result:

C# (CSharp) Example

ILookup

Tom Hines — Fri, 12 Feb 2010 23:37:25 GMT

There are many times where I need to convert an array of data into a Dictionary or Hash table. If the key to be used in the new Dictionary is not unique, it is necessary to manage duplicates. I previously went through a lot of gyrations, but eventually setteled on the ILookup. ILookup is not perfect, but it beats some alternatives.

Note this example (given the following structure):

public static List<string[]> lst_arr_strData = new List<string[]>()
{
   new string[] {"fred", "1"},
   new string[] {"joe", "1"},
   new string[] {"bill", "1"},
   new string[] {"sam", "1"},
   new string[] {"dave", "1"},
   new string[] {"fred", "2"},
   new string[] {"joe", "2"}
};

Technique 0: Throw an Exception : Argument Exception : Message="An item with the same key has already been added."

Technique 1: Ignore/discard duplicates

Technique 2: Add the duplicate data as an Enumerable type
Example: Dictionary<TKey, List<TValue>>

ToLookup converts an IEnumerable<T> to a Lookup<Key, Element> type. Lookup is like a dictionary, but where a Dictionary uses a single key value, Lookup maps the keys to a collection of values. Lookups have no public constructor and are immutable. You cannot add or remove elements or keys after they are created.

Technique 3: Convert the data using the Enumerable.ToLookup

ILookup<TKey, TElement>
http://msdn.microsoft.com/en-us/library/bb549073.aspx

In this example, I show the calling code and the ILookup solution in C++, C# and VB

////////////////////////////////////////////////////////////////////////////////
// CSharp Main program
using System;
using System.Collections.Generic;
using System.Linq;
using LinqTestCPP;
using LinqTestCS;
using LinqTestVB;
//
namespace LinqTestShell
{
   class LinqTest
   {
      //////////////////////////////////////////////////////////////////////////
      // here is some static data to convert to the ILookup
      public static List<string[]> lst_arr_strData = new List<string[]>()
      {
         new string[] {"fred", "1"},
         new string[] {"joe", "1"},
         new string[] {"bill", "1"},
         new string[] {"sam", "1"},
         new string[] {"dave", "1"},
         new string[] {"fred", "2"},
         new string[] {"joe", "2"}
      };

      static void Main(string[] args)
      {
         // Interfaces will/should look exactly the same.
         Console.WriteLine("--- C++   ---");
         CLinqTestCPP.LinqTest(lst_arr_strData);

         Console.WriteLine("--- CSharp ---");
         CLinqTestCS.LinqTest(lst_arr_strData);

         Console.WriteLine("---   VB   ---");
         CLinqTestVB.LinqTest(lst_arr_strData);
      }
   }
}

C++ Example:

// CPP implementation
#pragma once
using namespace System;
using namespace System::Collections::Generic;
using namespace System::Linq;

namespace LinqTestCPP {

       public ref class CLinqTestCPP
       {
       protected:
              //
              static String^ GetFirst(array<String^>^ arr){
                     return Enumerable::First<String^>(arr);
              }

       public:
              //
              static void LinqTest(List<array<String^>^>^ lst_arr_strData)
              {
                     ILookup<String^, array<String^>^>^ lkup =
                           Enumerable::ToLookup(lst_arr_strData,
                                  gcnew Func<array<String^>^, String^>(GetFirst)
                                  );

                     for each (IGrouping<String^, array<String^>^>^ arr in lkup)
                     {
                           Console::Write(arr->Key);

                           for each (array<String^>^ s in arr)
                           {
                                  Console::Write("\t" + s[1]);
                           }

                           Console::WriteLine();
                     }
              }
       };
}

C# (CSharp) Example:

////////////////////////////////////////////////////////////////////////////////
// CSharp implementation
using System;
using System.Collections.Generic;
using System.Linq;

namespace LinqTestCS
{
   public class CLinqTestCS
   {
      public static void LinqTest(List<string[]> lst_arr_strData)
      {
         // (using Extension)
         /* ILookup<string, string[]> lkup =
               lst_arr_strData.ToLookup(key => key.First()); */

         ILookup<string, string[]> lkup =
            Enumerable.ToLookup(lst_arr_strData,
               new Func<string[], String>(Enumerable.First)
               );

         foreach (IGrouping<string, string[]> arr in lkup)
         {
            Console.Write(arr.Key);
            foreach (var s in arr)
            {
               Console.Write("\t" + s[1]);
            }

            Console.WriteLine();
         }
      }
   }
}

VB Example:

' //////////////////////////////////////////////////////////////////////////////
' // VB Implementation
Imports System.Linq

Public Class CLinqTestVB

   Public Shared Sub LinqTest(ByVal lst_arr_strData As List(Of String()))
      ' (using Extension)
      ' Dim lkup As ILookup(Of String, String()) = _
      ' lst_arr_strData.ToLookup(Function(key) key.First())

      Dim lkup As ILookup(Of String, String()) = _
         Enumerable.ToLookup(lst_arr_strData, _
            New Func(Of String(), String)(AddressOf Enumerable.First))

      For Each arr As IGrouping(Of String, String()) In lkup
         Console.Write(arr.Key)

         For Each s As String() In arr
            Console.Write(Chr(9) + s(1))
         Next

         Console.WriteLine()
      Next

   End Sub
End Class

:and the output...:

My New Internet Explorer 8 Homepage

Tom Hines — Mon, 25 Jan 2010 19:50:27 GMT

Here is what I see most of the time I run IE8, now.
I guess I could consider it my new home page!

Your last browsing session closed unexpectedly.
Would you like to restore your last session, or go to your home page?
Restore last session
Go to home page

Hmpfh...

Utility that uses the CUserDomainSid class

Tom Hines — Fri, 08 Jan 2010 04:53:16 GMT

In the last post, I illustrated a module that retrieves the User, Domain and SID from the Windows System.Management namespace. In this post, I'm showing a practical application for that module.

This utility can be used if a user finds that access to the system registry or add/remove programs has been accidentally denied. Of course, this can also be done with a VBS script (run with Wscript.exe).

Potential error messages:

Registry editing has been disabled by your administrator.
Add or Remove Programs has been restricted. Please check with your administrator.

This was created with Visual Studio Standard 2008 and at least .NET 2.0.

using System;
using Microsoft.Win32;
using UserDomainSid; //...from previous post
namespace RegRelease
{
   class CRegRelease
   {
      public static string GetSid()
      {
         CUdsObj uds = CUserDomainSid.GetUDS();
         return uds.strSID;
      }

      static void Main(string[] args)
      {
         string strSid = GetSid();

         Registry.SetValue(
            @"HKEY_USERS\" + strSid +
            @"\Software\Microsoft\Windows\CurrentVersion\Policies\System",
            "DisableRegistryTools", 0, RegistryValueKind.DWord);

         Registry.SetValue(
            @"HKEY_USERS\" + strSid +
            @"\Software\Microsoft\Windows\CurrentVersion\Policies\Uninstall",
            "NoAddRemovePrograms", 0, RegistryValueKind.DWord);
      }
   }
}

Using System.Management to get the User, Domain and SID

Tom Hines — Thu, 07 Jan 2010 22:22:03 GMT

I have seen a few examples of VBS scripts used to get the User ID, Domain and SID of the current user.
This information is valuable when making registry modifications for the current user programatically.
I needed a way to retrieve that information in a .NET module to include in other .NET programs.
Here is my adaptation:

using System.Management; //Be sure to add this as a Reference, also.

namespace UserDomainSid
{
   /// <summary>
   /// Object returned by the call to CUserDomainSid.GetUDS()
   /// </summary>
   public class CUdsObj
   {
      /// <summary>
      /// Domain prefix for the user
      /// </summary>
      public string strDomain
      {
         get;
         set;
      }

      /// <summary>
      /// User ID
      /// </summary>
      public string strUser
      {
         get;
         set;
      }

      /// <summary>
      /// SID for the user
      /// </summary>
      public string strSID
      {
         get;
         set;
      }

      /// <summary>
      /// Constructor
      /// </summary>
      public CUdsObj()
      {
         strDomain = "";
         strUser = "";
         strSID = "";
      }
   }
   /// <summary>
   /// Extracts the User, Domain and SID of the current user.
   /// </summary>
   public class CUserDomainSid
   {
      /// <summary>
      /// The root scope of the query.
      /// </summary>
      private static string strScope = @"\\.\root\cimv2";
      /// <summary>
      /// Use the System.Management namespace to get the current
      /// User, Domain and SID.
      /// This is useful for querying and setting certain values
      /// in the system registry.
      /// </summary>
      /// <returns>CUserDomainSid</returns>
      public static CUdsObj GetUDS()
      {
         CUdsObj udsRetVal = new CUdsObj();
         //
         // UserName will contain the domain and the user
         string strQuery = "Select UserName FROM Win32_ComputerSystem";

         ///////////////////////////////////////////////////////
         // Query the ManagementObject to find the current user
         using (ManagementObjectSearcher mosItems =
            new ManagementObjectSearcher(strScope, strQuery))
         {
            foreach (ManagementBaseObject mbo in mosItems.Get())
            { //ManagementObjectCollection
               string[] arr_strUserDom =
                                                  mbo["UserName"].ToString().Split('\\');

               udsRetVal.strDomain = arr_strUserDom[0];
               udsRetVal.strUser = arr_strUserDom[1];
            }
         }

         udsRetVal.strSID =
             GetSid(udsRetVal.strDomain, udsRetVal.strUser);

         return udsRetVal;
      }

      /// <summary>
      /// GetSid uses the System.Management namespace to obtain the SID
      /// for a given domain and user name
      /// </summary>
      /// <param name="strDomain">the user's domain</param>
      /// <param name="strUser">the user's login ID</param>
      /// <returns>string (SID)</returns>
      public static string GetSid(string strDomain, string strUser)
      {
         string strRetValSid = "";
         ///////////////////////////////////////////////////////////////
         // Create a new query into the Win32_UserAccount to get the SID
         #region QUERY_REGION
         string strQuery =
            string.Format(
            // Go directly to the SID bypassing all others
               "Select SID " +
               "FROM Win32_UserAccount " +
               "WHERE" +
               " Domain='{0:G}'" +
               " AND Name='{1:G}'",
               strDomain, strUser);
         #endregion QUERY_REGION

         /////////////////////////////////////////////////////////////
         // Run the second query once we have the user name and Domain
         using (ManagementObjectSearcher mosItems =
            new ManagementObjectSearcher(strScope, strQuery))
         { //ManagementObjectCollection
            foreach (ManagementBaseObject mbo in mosItems.Get())
            { // Go directly to the SID bypassing all others
               strRetValSid = mbo["SID"].ToString();
            }
         }

         return strRetValSid;
      }
   }
}

Web Services Call including the XML and Linq namespaces

Tom Hines — Fri, 01 Jan 2010 21:47:20 GMT

I like using ASMX Web Services (WS)in my code -- either creating them or just calling them.
(Yes, I use Windows Communication Foundation (WCF) also).

One of the best features of the WS call is that the object model can be exposed to allow the caller to return specific results that need no additional parsing. This does not hold up, however, if the result is returned in a string of raw XML as the result may require additional parsing to be of best use.

Here is an example of calling Web Services where:

The Web Service returns raw XML without object formatting
(called by HTTP)
and the XmlDocument is used to parse the result.
The Web Service returns raw XML without object formatting
(called by SOAP)
and the XmlDocument is used to parse the result.
The Web Service returns a regular object
and no active XML treatment is needed.

I created this using using Visual Studio 2008 Standard calling to two different Web Services that provide Stock Quotes.
Here is an AltaVista query that can be used to find Web Services on the web.

using System;
using System.Linq;
using System.Xml.Linq;
//
//using Snag.WS_SQ;
using Snag.WS_Nexus6;

namespace Snag
{
   class CSnag
   {
      /// <summary>
      /// Main()
      /// </summary>
      static void Main(string[] args)
      {
         string strStockSymbol = "ERIC";//Ericsson
         Console.WriteLine("WS=" + GetWsToXmlLastValue(strStockSymbol));
         Console.WriteLine("XD=" + GetXdToXmlLastValue(strStockSymbol));
         Console.WriteLine("SO=" + GetWsToSoapLastValue(strStockSymbol));
      }

      /// <summary>
      /// Makes a call to a web service that implements the SOAP HTTP binding
      /// and parses the XML (string) response.
      ///
      /// This example is for calls that return XML not returned in
      /// a pre-parsed object.
      /// </summary>
      /// <param name="strStockSymbol"></param>
      /// <returns>the last value of the stock</returns>
      private static string GetXdToXmlLastValue(string strStockSymbol)
      {
         XDocument xd = XDocument.Parse( XDocument.Load(
            "http://www.webservicex.net/stockquote.asmx/GetQuote?symbol="
            + strStockSymbol).Descendants().First().Value);

         return xd
            .Element("StockQuotes").Element("Stock").Element("Last").Value;
      }

      /// <summary>
      /// Makes a regular WebService call using SOAP
      /// and parses the XML (string) response.
      ///
      /// This example is for calls that return XML not returned in
      /// an object
      /// </summary>
      /// <param name="strStockSymbol"></param>
      /// <returns>the last value of the stock</returns>
      private static string GetWsToXmlLastValue(string strStockSymbol)
      {
         using (WS_SQ.StockQuote ws = new WS_SQ.StockQuote())
         {
            XDocument xd =
               XDocument.Parse(ws.GetQuote(strStockSymbol));

            return xd
               .Element("StockQuotes").Element("Stock").Element("Last").Value;
         }
      }

      /// <summary>
      /// Makes a regular WebService call using SOAP
      /// where an object is returned.
      /// </summary>
      /// <param name="strStockSymbol"></param>
      /// <returns>the last value of the stock</returns>
      private static string GetWsToSoapLastValue(string strStockSymbol)
      {
         using (StockQuoteService sqs = new StockQuoteService())
         {
            return sqs.GetStockQuote(strStockSymbol).LastTrade;
         }
      }
   }
}

Linq to XML Example (Parsing RSS XML)

Tom Hines — Wed, 30 Dec 2009 05:32:17 GMT

[Discalimer]
This is just fun code and nothing too serious. Anything bigger than this should be hosted on a site where others can contribute.

[The Story]
A while back, someone asked a question on Twitter concerning LINQ to XML. I made a small example then as a proof of concept, then i kept playing with it until I came up with a lite framework for a utility that can be used to search and download DotNetRocks podcasts.

Right now, the utility is a stand-alone command-line app, but is written in such a way that it could be used in any type of app (graphical or other).

[What it does:]
The utility parses the XML of the RSS feed and allows searches by keyword into the title and description of the podcasts.
When the proper ones are found, they can be downloaded (into the "temp" directory).

Here is the feed it parses:
http://www.pwop.com/feed.aspx?show=dotnetrocks&filetype=master#

The "meat" of the program is in the function: GetMp3ListBySubject();

// DownloadDnr.cs
////////////////////////////////////////////////////////////////////////////////
// This program downloads content from the DotNetRocks repository based on the
// given search criteria.
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Xml.Linq;
using System.Resources;

namespace DownloadDnr
{
   partial class CDownloadDnr
   {
      static string m_strUsage = "DownloadDnr {theme} {auto}\n"
               + "\twhere {theme} is the search word for the"
               + " show(s) to be downloaded.\n\n"
               + "[Example:]\n\tDownloadDnr \"kate gregory\" auto\n"
               + "\twill list and download all shows mentioning\n"
               + "\tKate Gregory into the %temp% directory automatically.\n"
               + "\twithout asking the user.";

      static int m_intNumFilesProcessed = 0;

      static void Main(string[] args)
      {
         string strError = "";

         Func<string, bool> isArg =
            s => args.Skip(1).Any(s2 => s2.ToUpper().Equals(s));

         if (args.Length.Equals(0))
         {
            Console.WriteLine(m_strUsage);
            return;
         }

         List<CDnrResponse> lst = new List<CDnrResponse>();

         if (!GetMp3ListBySubject(args[0], ref lst, ref strError))
         {
            Console.WriteLine("Error getting list: " + strError);
            return;
         }

         if (lst.Count.Equals(0))
         {
            Console.WriteLine("Not found");
            return;
         }

         lst.ForEach(s => Console.WriteLine(s.ToString()));

         if (isArg("CLEAN"))
         {
            Console.WriteLine("Deleting: ");

            m_intNumFilesProcessed = 0;
            foreach (bool blnDeleted in DoClean(lst))
            {
               Console.WriteLine("File {0:G} deleted : " + lst[m_intNumFilesProcessed - 1],
                  (blnDeleted ? "has been" : "NOT found or"));
            }

            return;
         }

         if (!isArg("AUTO"))
         {
            if ('N'.Equals(ConsoleAskYesNo("Download this content? [Y/n]")))
            {
               Console.WriteLine("\n...aborted...");
               return;
            }
         }
         else
         {
            Console.Write("Auto ");
         }

         Console.WriteLine("Downloading:");

         ///////////////////////////////////////////////////////////////////////
         // Display the progress
         foreach (bool blnDownloaded in DoDownload(lst))
         {
            Console.WriteLine("{0:G}/{1:G} "
               + (blnDownloaded ? "Good: " : "Bad: ")
               + lst[m_intNumFilesProcessed-1],
               (m_intNumFilesProcessed), lst.Count);
         }
      }
   }
}

//ConsoleAskYesNo.cs
using System;
using System.Linq;

namespace DownloadDnr
{
   partial class CDownloadDnr
   {
      public static char ConsoleAskYesNo(string strQuestion)
      {
         char chrSelection = '\0';

         Func<char> GetUpperChar = delegate()
         { return Console.ReadKey().KeyChar.ToString().ToUpper()[0]; };

         string strValid = "NY\n";

         do
         {
            Console.WriteLine(strQuestion);
         } while (!strValid.Contains(chrSelection = GetUpperChar()));

         return chrSelection;
      }
   }
}

//DnrResponse.cs
namespace DownloadDnr
{
   public class CDnrResponse
   {
      public string strTitle
      {
         get;
         set;
      }

      public string strMp3
      {
         get;
         set;
      }

      public string strShowNum
      {
         get;
         set;
      }

      public CDnrResponse()
      {
         strTitle = "";
         strMp3 = "";
         strShowNum = "";
      }

      public CDnrResponse(CDnrResponse dnr)
      {
         strTitle = dnr.strTitle;
         strMp3 = dnr.strMp3;
         strShowNum = dnr.strShowNum;
      }

      public CDnrResponse(string strTitle, string strMp3, string strShowNum)
      {
         this.strTitle = strTitle.Trim();
         this.strMp3 = strMp3.Trim();
         this.strShowNum = strShowNum.Trim();
      }

      public override string ToString()
      {
         return strTitle + " (" + strShowNum + ")";
      }

      public override int GetHashCode()
      {
         return this.ToString().GetHashCode();
      }

      public override bool Equals(object obj)
      {
         return this.ToString().Equals(((CDnrResponse)obj).ToString());
      }
   }
}

//DoClean.cs
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;

namespace DownloadDnr
{
   partial class CDownloadDnr
   {
      public static IEnumerable<bool> DoClean(List<CDnrResponse> lst_dnrFiles)
      {
         bool blnRetVal = true;
         string strTempPath = Path.GetTempPath();
         foreach (CDnrResponse dnrResp in lst_dnrFiles)
         {
            blnRetVal = true;

            try
            {
               string strTargetFile =
                  strTempPath
                  + dnrResp.strMp3.Split("\\/".ToCharArray()).Last();

               m_intNumFilesProcessed++;

               if (!File.Exists(strTargetFile))
               {
                  blnRetVal = false;
               }
               else
               {
                  File.Delete(strTargetFile);
               }
            }
            catch (Exception exc)
            {
               blnRetVal = false;
               System.Diagnostics.Trace.WriteLine(
                  "Delete Failed: " + exc.Message);
            }

            yield return blnRetVal;
         }
      }
   }
}

//DoDownload.cs
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;

namespace DownloadDnr
{
   partial class CDownloadDnr
   {
      public static IEnumerable<bool> DoDownload(List<CDnrResponse> lst_dnrFiles)
      {
         bool blnRetVal = true;

         WebClient wc = new WebClient();
         string[] arr_strTemp = null;
         string strTempDir = Path.GetTempPath();
         //
         foreach (CDnrResponse dnrResp in lst_dnrFiles)
         {
            blnRetVal = true;
            arr_strTemp = dnrResp.strMp3.Split("\\/".ToCharArray());
            try
            {
               wc.DownloadFile(
                  new Uri(dnrResp.strMp3), strTempDir + arr_strTemp.Last());

               m_intNumFilesProcessed++;
            }
            catch (Exception exc)
            {
               blnRetVal = false;
               System.Diagnostics.Trace.WriteLine(
                  "Download Failed: " + exc.Message);
            }

            yield return blnRetVal;
         }
      }
   }
}

//GetMp3ListBySubject.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Xml.Linq;

namespace DownloadDnr
{
   partial class CDownloadDnr
   {
      //////////////////////////////////////////////////////////////////////////
      // Return the list of MP3s containing titles or descriptions matching the
      // given criteria.
      static bool GetMp3ListBySubject(string strSubject,
         ref List<CDnrResponse> lst_dnrRetVal, ref string strError)
      {
         bool blnRetVal = true;
         //
         Func<XAttribute, string> UnUrl = s =>
            s.ToString().Replace("url=", "").Replace("\"", "");
         //
         Func<XElement, string> EpNum = s =>
            s.ToString().Split(
               "=<>".ToCharArray(), StringSplitOptions.RemoveEmptyEntries)
               .Where(s2 => !s2.Equals("/guid")).ToArray().Last();
         //
         try
         {
            string strUpSubj = strSubject.ToUpper();
            /////////////////////////////////////////
            // Load the page as an XML document
            XDocument xdocDotNetRocks = XDocument.Load(
               "http://www.pwop.com/feed.aspx?show=dotnetrocks&filetype=master#"
               );

            ////////////////////////////////////////////////////////////////////
            // SELECT title, mp3, episodeNum FROM xdocDotNetRocks
            // WHERE (UPCASE(title) LIKE '%LINQ%')
            // OR (UPCASE(description) LIKE '%LINQ%')
            // OR (UPCASE(guid) LIKE '%LINQ%');
            lst_dnrRetVal =
            (
               from XElement xe in xdocDotNetRocks.Descendants("item")
               let strTitle = xe.Element("title").Value
               let strEpNum = EpNum(xe.Element("guid"))
               let strMp3 = UnUrl(xe.Element("enclosure").Attributes("url").First())
               let strDesc = xe.Element("description").Value
               where strTitle.ToUpper().Contains(strUpSubj)
               || strDesc.ToUpper().Contains(strUpSubj)
               || strEpNum.Equals(strUpSubj)
               select new CDnrResponse(strTitle, strMp3, strEpNum)
            ).Distinct().ToList<CDnrResponse>();
         }
         catch (Exception exc)
         {
            blnRetVal = false;
            strError = exc.Message;
         }

         return blnRetVal;
      }
   }
}

There is no disc in the drive. (fixed)

Tom Hines — Fri, 18 Dec 2009 21:20:54 GMT

YES THERE IS!

I'm using a Dell Latitude D620 Laptop (with Windows XP Pro).
I burn a lot of CDs for various reasons.
One error from the CD Writing Wizard I frequently receive (and have not yet found a permanent solution) is the "There is no disc in the drive." / "Insert a writable disc to continue." error -- even when there IS, in fact, a disc in the drive.

Rebooting will SOMETIMES fix the problem, but is not necessary.

To fix this, I'll go to the drive properties of the CD RW drive (right click) and select the "Recording" tab.
Once there, I'll UNCHECK the "Enable CD recording on this drive" checkbox and click "Apply".

A message will appear and I'll click "Yes" to continue.

I'll then go back into the properties and re-check that same checkbox and click "OK".
Then right-click the drive and tell it to "Write these files to CD".

Works every time:

I've gotten very accustomed to doing this and it no longer surprises me when it happens.

CInternetSession Debug Assertion Failed (Fixed)

Tom Hines — Fri, 18 Dec 2009 19:08:19 GMT

I had completely forgotten about the Debug Assertion Failure when invoking the MFC CInternetSession from a console application.

I recently needed to teach an Old Dog a New Trick by performing an MFC FTP upload from a .NET (C#) console application.

When running the app in debug mode, I got the "Debug Assertion Failed" dialog box that requires an answer of Abort, Retry or Ignore.

I remembered (from long ago) this is a benign error and can just be ignored (if you want to press a button), but I didn't want any surprises and I wanted "clean" code.

In the rare instance someone else might run across this, here is the SHORT solution:

Modify your header to include <afx.h>, <afxinet.h> and <afxwin.h>
Add a module-level instance of CWinApp (yes, even in a console app).
Set a value in your code for the variable afxCurrentAppName before invoking the CInternetSession

Here is the LONG solution

The error reported says there is a failure in the file afxwin1.inl at line 29.
After some disk searching, I found the file, afxwin1.inl, and saw the problem line 29:

...which simply checks to see if the variable afxCurrentAppName has a value.

afxCurrentAppName is an alias for AFX_MODULE_STATE::m_lpszCurrentAppName of type LPCTSTR in file afxstat_.h that is NOT automatically when making a console app (deeper explanation not given in this post).

Here's a test line of code that will cause the error:

Here is the dialog box showing the Debug Assertion Failure:

Here are the modifications to stop the error:
First, modify the header:

...then modify the code:

I have not run across any negative side-effects by doing this.

GZipLib (playing with GZipStream)

Tom Hines — Fri, 16 Oct 2009 18:19:28 GMT

I recently needed to un-gzip (gUnzip?) a large amount of files programatically and eventually ended up with the class/library posted below.

With the GZipStream (.NET / dot net), I had seen a lot of examples compressing and decompressing strings in memory, but I needed the straight-forward, simple method of just compressing and inflating/decompressing a file (in the simplest manner).

I made the buffer size modifiable to allow you to customize the amount of RAM needed for the process.

In all of this, I discovered the proper way to name a .gz file is the name of the contents (1 file) plus the extension .gz.

Example: manish.txt becomes manish.txt.gz.

This helps tools like WinZip decipher the contents as that .gz name is used when inflating/decompressing.

With this class, you can compress and decompress with or without the output filenames.

I originally posted the C# (csharp) code here, but it was a bit sloppy, so I zipped the project (with WinZip (ha ha)).

Download the project here.

using System.IO.Compression;


Here is a tester for the library: