Tom Hines (writinThatCode.com)

Linq Challenge in C++

2012-02-10T16:53:29-06:00:00

I really love the LINQ language extension in dot net programming and I’m really glad it was added to a language I love (C#).

My background, however, has a lot of C++ in it and I still do some coding in C++ – sometimes for fun and sometimes to put back into practice things I should have know for years, but are just now being recognized by my ever-widening eyes. A lot of that new vision comes from seeing C# and LINQ and, of course, practicing all forms of programming MOJO on programming forums, like DaniWeb.com.

One particular post I saw there was in the C++ forum, where a user posted a question about two-dimensional arrays and how to search for a particular pattern of digits based on array boundaries. The user posted a block of digits like this:
2,2,9,8,7,3,4,
0,0,0,0,0,0,0,
3,4,5,7,8,9,6,
0,0,0,0,0,0,0,
1,3,4,5,5,5,5

The question asked was how to return a 2d array of the rows that did not contain “all” zero values. Most programmers can imagine a series of loops and boolean settings based on boundaries to eliminate the “bad” rows.

I immediately thought “Use a WHERE clause on it”. …then I remembered I was in the C++ forum and, given the experience of the developer, might need a more traditional approach. I gave a suggestion about looping then began to make some examples for myself – one full solution “the (traditional) hard way”, one solution in C# with LINQ and then curiosity took hold and I convinced myself it would not be “too hard” to do it with C++ (CLI) and LINQ. I underestimated the complexity, but consider it good practice.

Here is the C# code:

using System.Collections.Generic;
using System.Linq;
//
namespace DW_409646_CS_CON
{
   class Program
   {
      public static int[,] matrix2d = new int[5, 7]
      {
         {2,2,9,8,7,3,4},
         {0,0,0,0,0,0,0},
         {3,4,5,7,8,9,6},
         {0,0,0,0,0,0,0},
         {1,3,4,5,5,5,5}
      };

      static void Main(string[] args)
      {
         List<int> lst_int = matrix2d.OfType<int>().ToList();
         //
         int intHeight = (matrix2d.GetUpperBound(0) + 1);
         int intWidth = (matrix2d.GetUpperBound(1) + 1);

         // Method one
         int[][] arr =
         (
            from i in Enumerable.Range(0, intHeight)
            let lst_intEachRow = lst_int.GetRange(i * intWidth, intWidth)
            where !lst_intEachRow.All(ix => ix.Equals(0))
            select lst_intEachRow.ToArray()
         ).ToArray();

         // Method two
         int[][] arr2 =
            Enumerable.Range(0, intHeight)
               .Select(i => lst_int.GetRange(i * intWidth, intWidth)
                  .ToArray()).Where(xa => !xa.All(ix => ix.Equals(0)))
                     .ToArray();
      }
   }
}

The C++ conversion was a little more complex, but can be done. The tricky part was getting the return value from the Enumerable based on the height of the array:

   1:  #include "stdafx.h"

   2:  using namespace System;

   3:  using namespace System::Collections::Generic;

   4:  using namespace System::Linq;

   5:  //

   6:  public ref class CArrayHelper

   7:  {

   8:  public:

   9:     static array<int,2>^ matrix2d;

10:

  11:     CArrayHelper(array<int,2>^ matrix)

  12:     {

  13:        matrix2d = matrix;

  14:     }

15:

  16:     static Func<int, String^>^ intToString =

  17:        gcnew Func<int, String^>(IntToString);

18:

  19:     static Func<int, bool>^ isZero =

  20:        gcnew Func<int, bool>(IsZero);

21:

  22:     static Func<array<int>^, bool>^ notAllZeroes =

  23:        gcnew Func<array<int>^, bool>(AllZeroes);

24:

  25:     static Func<int, int, array<int>^>^ getArrFromArr =

  26:        gcnew Func<int, int, array<int>^>(GetArrFromArr);

27:

  28:     static array<array<int>^>^ OutputArrayNonZeroes()

  29:     {

  30:        return

  31:           Enumerable::ToArray

  32:              (Enumerable::Where

  33:                 (Enumerable::Select

  34:                    (Enumerable::Range(0, matrix2d->GetUpperBound(0) + 1),

  35:                       getArrFromArr), notAllZeroes));

  36:     }

37:

  38:  private:

  39:     static String^ IntToString(int i)

  40:     {

  41:        return i.ToString();

  42:     }

43:

  44:     static bool IsZero(int i)

  45:     {

  46:        return i.Equals(0);

  47:     }

48:

  49:     static bool AllZeroes(array<int>^ arr)

  50:     {

  51:        return !Enumerable::All<int>(arr, isZero);

  52:     }

53:

  54:     static array<int>^ GetArrFromArr(int i, int j)

  55:     {

  56:        return

  57:           Enumerable::ToArray(

  58:              Enumerable::ToList<int>(

  59:                 Enumerable::ToArray(

  60:                    Enumerable::OfType<int>(matrix2d)))

  61:                       ->GetRange(i * (matrix2d->GetUpperBound(1) + 1),

  62:                          (matrix2d->GetUpperBound(1) + 1)));

  63:     }

  64:  };

65:

  66:  void DumpIntArray(array<int>^ arr_int)

  67:  {

  68:     Console::WriteLine(

  69:        String::Join(",",

  70:           Enumerable::ToArray(

  71:              Enumerable::Select<int>(

  72:                 Enumerable::ToArray<int>(arr_int), CArrayHelper::intToString))));

  73:  }

74:

  75:  int main(array<System::String ^> ^args)

  76:  {

  77:     Action<array<int>^>^ dumpIntArray = gcnew Action<array<int>^>(DumpIntArray);

78:

  79:     array<array<int>^>^ arrOutput = CArrayHelper(gcnew array<int,2>(5,7)

  80:     {

  81:        {2,2,9,8,7,3,4},

  82:        {0,0,0,0,0,0,0},

  83:        {3,4,5,7,8,9,6},

  84:        {0,0,0,0,0,0,0},

  85:        {1,3,4,5,5,5,5}

  86:     }).OutputArrayNonZeroes();

87:

  88:     Enumerable::ToList<array<int>^>(arrOutput)->ForEach(dumpIntArray);

  89:     return 0;

  90:  }

Programming Forums

2011-12-01T12:37:40-06:00:00

Here is a list of programming forums I visit for:

Seeing what programmers are currently learning
Seeing what makes programmers struggle
Answering programming questions
Asking programming questions

The sites require (free) registration and, in different ways, keep track of points you earn for participation as well as a reputation score.

Here they are in no specific order:

Releasing Email File Attachment Resources (System.Net.Mail)

2011-07-14T11:40:53-05:00:00

I’ve been looking through the temp directories on my production machines and had realized some overlooked design points in a number of programs; namely the deletion of certain temp files.

One situation that particularly caught my attention was some email attachments that should have been deleted.
Even though the code was actively calling File.Delete() on some email attachments, they were not being deleted.
An error log showed the program was throwing an exception when attempting to delete the files.
The mail was being delivered successfully with no visible flaws to the customer.

I finally decided to write some test code to reproduce the problem that I originally thought was caused by the ZIP compression step right before the mail send.

The problem actually turned out to be I was not calling Dispose() on the attachment resources after the mail send. Most Dot Net classes I use don’t require the explicit calling of a Dispose() method, so I completely bypassed this one until it became necessary. Here’s an example of the solution:

using System;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Net.Mail;

…

   1:        /// <summary>

   2:        /// Example of simple mailing with attachment and release of attachments.

   3:        /// </summary>

   4:        /// <param name="lst_strAttachments">List&lt;string&gt;

   5:        /// filenames to attach to the email.

   6:        /// </param>

   7:        /// <param name="strError">Output of exception text</param>

   8:        /// <returns>bool: true if no exceptions</returns>

   9:        public static bool SendMail(List<string> lst_strAttachments, ref string strError)

  10:        {

  11:           bool blnRetVal = true;

  12:           try

  13:           {

  14:              string strSubjectBody = "Test Email With Attachment";

15:

  16:              // Make a basic mail message

  17:              MailMessage msg = new MailMessage()

  18:              {

  19:                 Subject = strSubjectBody,

  20:                 Body = strSubjectBody,

  21:                 Priority = MailPriority.Low,

  22:                 From = new MailAddress(EMAIL_ADDRESS_TO_FROM)

  23:              };

24:

  25:              msg.To.Add(msg.From); //same as from

  26:              //http://msdn.microsoft.com/en-us/library/system.net.mail.attachment.aspx

  27:              lst_strAttachments.ForEach(a => msg.Attachments.Add(new Attachment(a)));

28:

  29:              (new SmtpClient(SMTP_SERVER_ADDRESS)).Send(msg);

30:

  31:              // Free the attachment resources

  32:              msg.Attachments.ToList().ForEach(a => a.Dispose());

  33:           }

  34:           catch (Exception exc)

  35:           {

  36:              blnRetVal = false;

  37:              strError = exc.Message;

  38:           }

39:

  40:           return blnRetVal;

  41:        }

…and a small calling program example:
The Zip class is a custom wrapper.

   1:        static void Main(string[] args)

   2:        {

   3:           string strError = "";

   4:           string strTempFileName = CSampleTempFile.MakeSampleTempFile("One.txt");

   5:           string strZipFileName = Path.Combine(Path.GetTempPath(),"Test.zip");

6:

   7:           if (!CZipLib.ZipMove(strZipFileName,

   8:              new List<string>{strTempFileName}, //list of files (containing 1)

   9:              ref strError))

  10:           {

  11:              Console.WriteLine("Could not zip file {0:G}\n\t: {1:G}",

  12:                 strTempFileName, strError);

  13:              return;

  14:           }

15:

  16:           if (!SendMail(new List<string>{strZipFileName}, ref strError))

  17:           {

  18:              Console.WriteLine("Could not send mail: " + strError);

  19:              return;

  20:           }

21:

  22:           File.Delete(strZipFileName); //<--WORKS!

  23:        }

GridView from LINQ to Objects

2011-04-20T14:28:45-05:00:00

One of the greatest benefits I’ve found in simple web output in ASP.NET is the GridView. I regularly use it to display data from objects or databases where the output can simply be shown in a grid form (similar to instances where I would deliver a read-only spreadsheet).

I attach the GridView to the <asp:PlaceHolder /> inside of a <form /> on the aspx page:

A simple, bulk method of getting the data into the GridView is with the GridView.DataSource property.

A GridView.DataSource must be either an IListSource, IEnumerable, or IDataSource.

A natural partner to the GridView.DataSource property is the System.Data.DataSet.

Example:

Using the WebService located at: http://www.holidaywebservice.com/Holidays/US/USHolidayService.asmx .
I chose this WS, because it returns a DataSet (easy example).

   1:  using System;

   2:  using System.Collections.Generic;

   3:  using System.Data;

   4:  using System.Linq;

   5:  using System.Web.UI.WebControls;

6:

   7:  using WS_HOLIDAY;

   8:  public partial class _Default : System.Web.UI.Page

   9:  {

  10:     protected void Page_Load(object sender, EventArgs e) {}

11:

  12:     public void ShowReport()

  13:     {

  14:        GridView gvHolidays = new GridView()

  15:        {

  16:           HorizontalAlign = HorizontalAlign.Center,

  17:           GridLines = GridLines.Both,

  18:           BackColor = System.Drawing.Color.FromName("#CCCCCC"),

  19:           DataSource = (new USHolidayService()).GetHolidaysForYear(2011)

  20:        };

21:

  22:        holder.Controls.Add(gvHolidays);

  23:        gvHolidays.DataBind();

  24:     }

  25:  }

Result:

If the DataSource is to be a result of a LINQ query, the GridView will automatically choose the Property Names used in the return value (for known types with Properties).

If the returned type is Anonymous, you must supply the declarator that will be used a the Property Name as shown below.
(This will also work if you have a known type, but want to change the property names to be more appropriate.)
(This will also work if you have a returned object that used Fields instead of Properties):

Using Linq to Objects:

   1:  using System;

   2:  using System.Collections.Generic;

   3:  using System.Data;

   4:  using System.Linq;

   5:  using System.Web.UI.WebControls;

6:

   7:  public partial class _Default : System.Web.UI.Page

   8:  {

   9:     protected void Page_Load(object sender, EventArgs e) {}

10:

  11:     public void ShowReport()

  12:     {

  13:        //////////////////////////////////////////////////////

  14:        // simple func to parse a string by space and period

  15:        Func<string, string[]> WordParse = s =>

  16:        {

  17:           return s.Split(" .".ToCharArray(),

  18:              StringSplitOptions.RemoveEmptyEntries);

  19:        };

20:

  21:        //////////////////////////////////////////////////

  22:        // some random data representing a data source

  23:        List<string> lst_strData = new List<string>()

  24:        {

  25:           "This Is The Way We Funk With You",

  26:           "Open up your funky mind and you can fly.",

  27:           "Listen while I tell you of the clones.",

  28:           "You can't miss what you can't measure.",

  29:           "Hard as steel and still gettin' harder."

  30:        };

31:

  32:        //////////////////////////////////////////////////

  33:        // Create a GridView with some default settings.

  34:        GridView gv = new GridView()

  35:        {  //top-level atributes can be auto populated.

  36:           HorizontalAlign = HorizontalAlign.Center,

  37:           GridLines = GridLines.Both,

  38:           BackColor = System.Drawing.Color.FromName("#CCCCCC"),

  39:        };

40:

  41:        //////////////////////////////////////////////

  42:        // All other attributes are done separately.

  43:        // These are just my personal preferences

  44:        gv.RowStyle.HorizontalAlign = HorizontalAlign.Center;

  45:        gv.AlternatingRowStyle.BackColor = System.Drawing.Color.FromName("#EEEEEE");

  46:        gv.HeaderStyle.Font.Bold = true;

  47:        gv.HeaderStyle.BackColor = System.Drawing.Color.FromName("YELLOW");

  48:        gv.Font.Size = 9;

  49:        //

  50:        long lngRowNum = 0; //<-used to make the row counter

51:

  52:        gv.DataSource =

  53:           from str in lst_strData

  54:           let arr_str = WordParse(str)

  55:           where (arr_str.Count().Equals(7))

  56:           select new //ANONYMOUS TYPE

  57:           {

  58:              // ** Anonymous type members **

  59:              // These become the column names in the GridView!!!

  60:              NUM_SENTENCES = ++lngRowNum, //<-Auto-incrementing row counter

  61:              WORD1 = arr_str[0],

  62:              WORD2 = arr_str[1],

  63:              WORD3 = arr_str[2],

  64:              WORD4 = arr_str[3],

  65:              WORD5 = arr_str[4],

  66:              WORD6 = arr_str[5],

  67:              WORD7 = arr_str[6]

  68:           };

69:

  70:        holder.Controls.Add(gv);

  71:        gv.DataBind();

  72:     }

  73:  }

Result:

If the code does not supply the declarator/Property Name, an error will be generated:
Invalid anonymous type member declarator. Anonymous type members must be declared with a member assignment, simple name or member access.

Please let me know if this does not make any sense :)

Ambiguous Symbol -- Compiler Error C2872

2011-04-20T09:26:52-05:00:00

I recently encountered the Ambiguous Symbol error, specifically: “error C2872: 'IMasterLoader' : ambiguous symbol” when using an interface I wrote in C# with a class built in C++.

   1:  namespace IMasterLoader

   2:  {

   3:     public interface IMasterLoader<T> where T : class

   4:     {

   5:        bool Load(T master, ref string strError);

   6:     }

   7:  }

Code producing the error:

   1:  // LmCellSectorLog.h

   2:  #pragma once

   3:  using namespace System;

   4:  using namespace System::Collections::Generic;

   5:  using namespace System::Data;

6:

   7:  namespace LmCellSectorLog {

   8:      using namespace IMasterLoader;

   9:      public ref class CLmCellSectorLogLoader : IMasterLoader<CLmCellSectorLogMaster^>

  10:      {

  11:      public:

  12:          virtual bool Load(CLmCellSectorLogMaster^ master, String^% strError);

  13:      };

  14:  }

Compiler generated error C2872: 'IMasterLoader' : ambiguous symbol:

While searching for a solution to this problem, I encountered the Compiler Error C2872 (C++) page from MSDN, which didn’t have my exact solution, but led me to think differently about the syntax.

Jumping forward to the solution:

Assuming the problem was the compiler’s “scope” and recognition of the interface, I eventually changed the reference by fully qualifying the interface name with the “scope resolution operator (::)” and that solved the problem.

At that point, it was no longer necessary to reference the interface at the namespace:

   1:  public ref class CLmCellSectorLogLoader : ::IMasterLoader::IMasterLoader<CLmCellSectorLogMaster^>

   2:  {

   3:  public:

   4:      virtual bool Load(CLmCellSectorLogMaster^ master, String^% strError);

   5:  };

Technorati Tags: code,ambiguous symbol,.net,dot net,CSharp,CPlusPlus,C#,C++

ResponseStatusLine protocol violation

2010-12-03T11:10:21-06:00:00

I parse/scrape a few web page every now and then and recently ran across an error that stated:
"The server committed a protocol violation. Section=ResponseStatusLine".

Cause?:
On this page, I found an answer that suggests simply that the server header does not conform to the HTTP v1.1 specification.
[Paraphrased...]

This issue is caused when a response followed by a request to {certain} services violate the HTTP v1.1 specification.
As an example, HTTP header keys should specifically not include any spaces in their names.
Some web servers do not fully respect this which causes this error to occur.

The Microsoft .Net framework enforces the HTTP v1.1 specification and will reject any responses that do not adhere to the specification.
When a validation failure occurs then a protocol violation error is generated.

To resolve this issue any gateway/proxy level network components should been upgraded or corrected to properly adhere to the HTTP v1.1 specification.

After a few web searches, I found a couple of suggestions – one of which said the problem could be fixed by changing the HttpWebRequest ProtocolVersion to 1.0 with the command:

   1:  HttpWebRequest req = (HttpWebRequest)HttpWebRequest.Create(strURI);

   2:  req.ProtocolVersion = HttpVersion.Version10;

…but that did not work in my particular case.

What DID work was the next suggestion I found that suggested the use of the setting: “useUnsafeHeaderParsing” either in the app.config file or programmatically.

If added to the app.config, it would be:

   1:  <!-- after the applicationSettings -->

   2:  <system.net>

   3:      <settings>

   4:        <httpWebRequest useUnsafeHeaderParsing ="true"/>

   5:      </settings>

   6:  </system.net>

If done programmatically, it would look like this:

C++:

   1:  // UUHP_CPP.h

   2:  #pragma once

   3:  using namespace System;

   4:  using namespace System::Reflection;

5:

   6:  namespace UUHP_CPP

   7:  {

   8:      public ref class CUUHP_CPP

   9:      {

  10:      public:

  11:          static bool UseUnsafeHeaderParsing(String^% strError)

  12:          {

  13:              Assembly^ assembly = Assembly::GetAssembly(System::Net::Configuration::SettingsSection::typeid); //__typeof

  14:              if (nullptr==assembly)

  15:              {

  16:                  strError = "Could not access Assembly";

  17:                  return false;

  18:              }

19:

  20:              Type^ type = assembly->GetType("System.Net.Configuration.SettingsSectionInternal");

  21:              if (nullptr==type)

  22:              {

  23:                  strError = "Could not access internal settings";

  24:                  return false;

  25:              }

26:

  27:              Object^ obj = type->InvokeMember("Section",

  28:                  BindingFlags::Static | BindingFlags::GetProperty | BindingFlags::NonPublic,

  29:                  nullptr, nullptr, gcnew array<Object^,1>(0));

30:

  31:              if(nullptr == obj)

  32:              {

  33:                  strError = "Could not invoke Section member";

  34:                  return false;

  35:              }

36:

  37:              FieldInfo^ fi = type->GetField("useUnsafeHeaderParsing", BindingFlags::NonPublic | BindingFlags::Instance);

  38:              if(nullptr == fi)

  39:              {

  40:                  strError = "Could not access useUnsafeHeaderParsing field";

  41:                  return false;

  42:              }

43:

  44:              if (!(bool)fi->GetValue(obj))

  45:              {

  46:                  fi->SetValue(obj, true);

  47:              }

48:

  49:              return true;

  50:          }

  51:      };

  52:  }

C# (CSharp):

   1:  using System;

   2:  using System.Reflection;

3:

   4:  namespace UUHP_CS

   5:  {

   6:     public class CUUHP_CS

   7:     {

   8:        public static bool UseUnsafeHeaderParsing(ref string strError)

   9:        {

  10:           Assembly assembly = Assembly.GetAssembly(typeof(System.Net.Configuration.SettingsSection));

  11:           if (null == assembly)

  12:           {

  13:              strError = "Could not access Assembly";

  14:              return false;

  15:           }

16:

  17:           Type type = assembly.GetType("System.Net.Configuration.SettingsSectionInternal");

  18:           if (null == type)

  19:           {

  20:              strError = "Could not access internal settings";

  21:              return false;

  22:           }

23:

  24:           object obj = type.InvokeMember("Section",

  25:              BindingFlags.Static | BindingFlags.GetProperty | BindingFlags.NonPublic,

  26:              null, null, new object[] { });

27:

  28:           if (null == obj)

  29:           {

  30:              strError = "Could not invoke Section member";

  31:              return false;

  32:           }

33:

  34:           // If it's not already set, set it.

  35:           FieldInfo fi = type.GetField("useUnsafeHeaderParsing", BindingFlags.NonPublic | BindingFlags.Instance);

  36:           if (null == fi)

  37:           {

  38:              strError = "Could not access useUnsafeHeaderParsing field";

  39:              return false;

  40:           }

41:

  42:           if (!Convert.ToBoolean(fi.GetValue(obj)))

  43:           {

  44:              fi.SetValue(obj, true);

  45:           }

46:

  47:           return true;

  48:        }

  49:     }

  50:  }

F# (FSharp):

   1:  namespace UUHP_FS

   2:  open System

   3:  open System.Reflection

   4:      module CUUHP_FS =

   5:          let UseUnsafeHeaderParsing(strError : byref<string>) : bool  =

   6:              //

   7:              let assembly : Assembly = Assembly.GetAssembly(typeof<System.Net.Configuration.SettingsSection>)

   8:              if (null = assembly) then

   9:                  strError <- "Could not access Assembly"

  10:                  false

  11:              else

12:

  13:              let myType : Type = assembly.GetType("System.Net.Configuration.SettingsSectionInternal")

  14:              if (null = myType) then

  15:                  strError <- "Could not access internal settings"

  16:                  false

  17:              else

18:

  19:              let obj : Object = myType.InvokeMember("Section", BindingFlags.Static ||| BindingFlags.GetProperty ||| BindingFlags.NonPublic, null, null, Array.zeroCreate 0)

  20:              if (null = obj) then

  21:                  strError <- "Could not invoke Section member"

  22:                  false

  23:              else

24:

  25:              // If it's not already set, set it.

  26:              let fi : FieldInfo = myType.GetField("useUnsafeHeaderParsing", BindingFlags.NonPublic ||| BindingFlags.Instance)

  27:              if(null = fi) then

  28:                  strError <- "Could not access useUnsafeHeaderParsing field"

  29:                  false

  30:              else

31:

  32:              if (not(Convert.ToBoolean(fi.GetValue(obj)))) then

  33:                  fi.SetValue(obj, true)

34:

  35:              // Now return true

  36:              true

VB (Visual Basic):

   1:  Option Explicit On

   2:  Option Strict On

   3:  Imports System

   4:  Imports System.Reflection

5:

   6:  Public Class CUUHP_VB

   7:      Public Shared Function UseUnsafeHeaderParsing(ByRef strError As String) As Boolean

8:

   9:          Dim assembly As [Assembly]

  10:          assembly = [assembly].GetAssembly(GetType(System.Net.Configuration.SettingsSection))

11:

  12:          If (assembly Is Nothing) Then

  13:              strError = "Could not access Assembly"

  14:              Return False

  15:          End If

16:

  17:          Dim type As Type

  18:          type = [assembly].GetType("System.Net.Configuration.SettingsSectionInternal")

  19:          If (type Is Nothing) Then

  20:              strError = "Could not access internal settings"

  21:              Return False

  22:          End If

23:

  24:          Dim obj As Object

  25:          obj = [type].InvokeMember("Section", _

  26:              BindingFlags.Static Or BindingFlags.GetProperty Or BindingFlags.NonPublic, _

  27:          Nothing, Nothing, New [Object]() {})

28:

  29:          If (obj Is Nothing) Then

  30:              strError = "Could not invoke Section member"

  31:              Return False

  32:          End If

33:

  34:          ' If it's not already set, set it.

  35:          Dim fi As FieldInfo

  36:          fi = [type].GetField("useUnsafeHeaderParsing", BindingFlags.NonPublic Or BindingFlags.Instance)

  37:          If (fi Is Nothing) Then

  38:              strError = "Could not access useUnsafeHeaderParsing field"

  39:              Return False

  40:          End If

41:

  42:          If (Not Convert.ToBoolean(fi.GetValue(obj))) Then

  43:              fi.SetValue(obj, True)

  44:          End If

45:

  46:          Return True

  47:      End Function

  48:  End Class

Technorati Tags: C++,CPP,VB,Visual Basic,F#,FSharp,C#,CSharp,ResponseStatusLine,protocol violation

Playing with Enumerable.Range (System.Linq)

2010-09-08T15:18:05-05:00:00

Technorati Tags: Linq,Enumerable.Range,Intersect,F#,FS,C#,CS,C++,CPP,Visual Basic,VB

MSDN Reference: Enumerable.Range Method

I deal with a lot of RANGES at work for a multitude of reasons.
When auditing data and databases, it’s often necessary to check the boundaries of values or to set them.
I’ve recently become very fond of Enumerable.Range because it offers a lot of convenience when dealing with certain types of ranges and can allow a fair amount of complexity.

For instance:
If I need to represent a range of integers from 3 to 17, I could use the construct: Enumerable.Range(3, 15); //3-17
If I need to represent a range of integers from 22 to 24I could use the construct: Enumerable.Range(22, 3); //22-24

…and so on.

Also, I can merge those two non-contiguous ranges with: Enumerable.Range(3, 15).Union(Enumerable.Range(22, 3));
resulting in [3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,22,23,24]

I can also use the Enumerable set operations for comparisons like:

Contains(), Intersect(), Union(), Except(), etc.
and a host of other methods included in the class.

The most common action I do with sets and ranges is just a comparison for inclusion or exclusion.
This is of great benefit when comparing a list of numbers to a given
Where I would have previously used Enumerable.Contains(with lambda) to compare a list to a range,
I now use Enumerable.Intersect() as it is easiest to code in all four languages.

Note:

For carriage-return/linefeeds, I chose to use the Environment.NewLine to avoid having to change the string for each language
using “\n” for some and Chr(10) for VB.

For brevity with the C++, I put the classes in the .cpp file instead of putting the headers in a .h file.

Here are some examples:

C# Calling Program:

   1:  using System;

   2:  using System.Collections.Generic;

   3:  using System.Linq;

   4:  //

   5:  using EnumerableTest_CPP;

   6:  using EnumerableTest_CS;

   7:  using EnumerableTest_FS;

   8:  using EnumerableTest_VB;

9:

  10:  namespace CS_Test_2008_Sept_2010

  11:  {

  12:     class CCS_Test_2008_Sept_2010

  13:     {

  14:        static IEnumerable<int> i_eRange1 = Enumerable.Range(3, 15); //3-17

  15:        static IEnumerable<int> i_eRange2 = Enumerable.Range(22, 3); //22-24

16:

  17:        /************************[or this]***************************\

  18:        static IEnumerable<int> i_e =

  19:           Enumerable.Range(3, 15).Union(Enumerable.Range(22, 3));

  20:        \************************************************************/

  21:        static List<int> lst_intList = new List<int>() {

  22:              1,2,3,15,23,77,23,21,8,104,18,19,17

  23:        };

24:

  25:        static void Main(string[] args)

  26:        {

  27:           IEnumerable<int> i_eRange = i_eRange1.Union(i_eRange2);

28:

  29:           CEnumerableTest_CPP.TestEnumerable(lst_intList, i_eRange, 23);

  30:           CEnumerableTest_FS.TestEnumerable(lst_intList, i_eRange, 23);

  31:           CEnumerableTest_CS.TestEnumerable(lst_intList, i_eRange, 23);

  32:           CEnumerableTest_VB.TestEnumerable(lst_intList, i_eRange, 23);

  33:        }

  34:     }

  35:  }

C++ class Library:

   1:  #include "stdafx.h"

   2:  #include "EnumerableTest.h"

3:

   4:  using namespace EnumerableTest;

   5:  using namespace System;

   6:  using namespace System::Collections::Generic;

   7:  using namespace System::Linq;

8:

   9:  namespace EnumerableTest_CPP {

10:

  11:  public ref class CEnumerableTest_CPP

  12:  {

  13:  public:

  14:      static void TestEnumerable(List<int>^ lst_intFred, IEnumerable<int>^ eFred, int iTarget);

  15:  };

16:

  17:  public ref class CCompareInt : IComparer<int>

  18:  {

  19:  public:

  20:      virtual int Compare(int i1, int i2)    { return i1.CompareTo(i2); }

  21:  };

22:

  23:  int getInt(int iOrd1){ return iOrd1;}

24:

  25:  String^ IntToString(int iChoice){ return iChoice.ToString(); }

26:

  27:  void CEnumerableTest_CPP::TestEnumerable(List<int>^ lst_intList, IEnumerable<int>^ i_eRange, int iTarget)

  28:  {

  29:      Console::WriteLine(Environment::NewLine +

  30:          "i_eRange {0:G} my target number",

  31:          Enumerable::Contains(i_eRange, iTarget) ? "contains" : "does not contain");

32:

  33:      Console::WriteLine(

  34:          "Display all numbers in lst_intList that are included" + Environment::NewLine +

  35:          " in the {0:G} digits of i_eRange ranged from {1:G} to {2:G}",

  36:          Enumerable::Count(i_eRange), Enumerable::Min(i_eRange),

  37:          Enumerable::Max(i_eRange)

  38:          );

39:

  40:      Console::WriteLine(

  41:          String::Join(",",

  42:              Enumerable::ToArray<String^>(

  43:                  Enumerable::Select( // to convert for the String::Join

  44:                  Enumerable::OrderBy(

  45:                  Enumerable::Intersect(i_eRange, lst_intList),    // Intersect

  46:                          gcnew Func<int,int>(getInt)),    // OrderBy

  47:                          gcnew Func<int, String^>(IntToString)    // Select

  48:                  )    // Select

  49:              )    // ToArray

  50:          )    // Join

  51:      );    // WriteLine

  52:  }

  53:  }

F# class Library:

   1:  namespace EnumerableTest_FS

   2:  open System

   3:  open System.Collections.Generic

   4:  open System.Linq

5:

   6:      module CEnumerableTest_FS =

   7:          let getInt(i1:int) : int =  i1

   8:          let IntToString(i:int) : String = i.ToString()

   9:          //

  10:          let TestEnumerable(lst_intList:List<int>)(i_eRange:IEnumerable<int>)(iTarget:int) =

11:

  12:              Console.WriteLine(Environment.NewLine +

  13:                  "i_eRange {0:G} my target number", //ternary in F#

  14:                  (if Enumerable.Contains(i_eRange, iTarget)

  15:                      then "contains" else "does not contain"))

16:

  17:              Console.WriteLine("Display all numbers in lst_intList that are included"

  18:                  + Environment.NewLine +

  19:                  " in the {0:G} digits of i_eRange ranged from {1:G} to {2:G}",

  20:                  Enumerable.Count(i_eRange), Enumerable.Min(i_eRange),

  21:                  Enumerable.Max(i_eRange)

  22:                  );

23:

  24:              Console.WriteLine(

  25:                  String.Join(",",

  26:                      Enumerable.Select(

  27:                          Enumerable.OrderBy(

  28:                              Enumerable.Intersect(lst_intList, i_eRange),// Intersect

  29:                              new Func<int,int>(getInt)),// OrderBy

  30:                          new Func<int, String>(IntToString)).ToArray()))// Select

C# class Library:

   1:  using System;

   2:  using System.Collections.Generic;

   3:  using System.Linq;

4:

   5:  namespace EnumerableTest_CS

   6:  {

   7:     public class CEnumerableTest_CS

   8:     {

   9:        public static void TestEnumerable(List<int> lst_intList, IEnumerable<int> i_eRange, int iTarget)

  10:        {

  11:           Console.WriteLine("i_eRange {0:G} my target number", i_eRange.Contains(23) ? "contains" : "does not contain");

12:

  13:           Console.WriteLine(

  14:              "Display all numbers in lst_intList that are included" + Environment.NewLine +

  15:              " in the {0:G} digits of i_eRange ranged from {1:G} to {2:G}",

  16:              i_eRange.Count(), i_eRange.Min(), i_eRange.Max()

  17:              );

18:

  19:           Console.WriteLine("{0:G}",

  20:              string.Join(",",

  21:                 lst_intList.Distinct().OrderBy(i => i)

  22:                    .Intersect(i_eRange)

  23:                    .Select(i => i.ToString())

  24:                    .ToArray()));

  25:        }

  26:     }

  27:  }

VB class Library:

   1:  Public Class CEnumerableTest_VB

   2:      Public Shared Sub TestEnumerable(ByVal lst_intList As List(Of Integer), ByVal i_eRange As IEnumerable(Of Integer), ByVal iTarget As Integer)

   3:          Console.WriteLine( _

   4:              Environment.NewLine + _

   5:              "i_eRange {0:G} my target number", _

   6:              If(i_eRange.Contains(23), "contains", "does not contain"))

7:

   8:          Console.WriteLine( _

   9:              "Display all numbers in lst_intList that are included" + Environment.NewLine + _

  10:              " in the {0:G} digits of i_eRange ranged from {1:G} to {2:G}", _

  11:          i_eRange.Count(), i_eRange.Min(), i_eRange.Max())

12:

  13:          Console.WriteLine("{0:G}", _

  14:              String.Join(",", _

  15:              lst_intList.Distinct().OrderBy(Function(i) i) _

  16:              .Intersect(i_eRange) _

  17:              .Select(Function(i) i.ToString()) _

  18:              .ToArray()))

  19:      End Sub

  20:  End Class

OUTPUT from the run:

Packing a DBF

2010-03-23T11:37:31-05:00:00

I thought my days of dealing with DBFs as a "production data" source were over, but HA (no such luck).
I recently had to retrieve, modify and replace some data that needed to be delivered in a DBF file.

Everything was fine until I realized / remembered the DBF driver does not ACTUALLY delete records from the data source -- it only marks them for deletion. You are responsible for handling the "chaff" either by using a utility to remove deleted records or by simply ignoring them. If imported into Excel, the marked-deleted records are ignored, but the file size will reflect the extra content. After several rounds of testing CRUD, the output DBF was huge.

So, I went hunting for a method to "Pack" the records (removing deleted ones and resizing the DBF file) and eventually ran across the FOXPRO driver at ( http://msdn.microsoft.com/en-us/vfoxpro/bb190233.aspx ). Once installed, I changed the DSN in the code to the new one I created in the ODBC Administrator and ran some tests.

Using Microsoft Query, I simply tested the raw SQL command Pack {tablename} and it WORKED!
One really neat thing is the PACK command is used like regular SQL instructions; "Pack {tablename}" is all that is needed.
It is necessary, however, to close all connections to the database (and re-open) before issuing the PACK command or you will get the "File is in use" error.

Here is some C# code for a Pack method.

      /// <summary>
      /// Pack the DBF removing all deleted records
      /// </summary>
      /// <param name="strTableName">The table to pack</param>
      /// <param name="strError">output of any errors</param>
      /// <returns>bool (true if no errors)</returns>
      public static bool Pack(string strTableName, ref string strError)
      {
         bool blnRetVal = true;

         try
         {
            OdbcConnectionStringBuilder csbOdbc = new OdbcConnectionStringBuilder()
            {
               Dsn = "PSAP_FOX_DBF"
            };

            string strSQL = "pack " + strTableName;

            using (OdbcConnection connOdbc = new OdbcConnection(csbOdbc.ToString()))
            {
               connOdbc.Open();
               OdbcCommand cmdOdbc = new OdbcCommand(strSQL, connOdbc);
               cmdOdbc.ExecuteNonQuery();
               connOdbc.Close();
            }
         }
         catch (Exception exc)
         {
            blnRetVal = false;
            strError = exc.Message;
         }

         return blnRetVal;
      }

Geek Quiz

2010-03-22T12:03:09-05:00:00

70% Geek

Calling An ASMX Web Service From Different Languages

2010-03-07T22:07:25-06:00:00

[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()

----------------------------[SuppressWarning.rb]----------------------------

def suppress_warning
    back = $VERBOSE
    $VERBOSE = nil
    begin
      yield
    ensure
      $VERBOSE = back
    end
end

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

2010-03-05T17:22:11-06:00:00

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

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; // virtual 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

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
}

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

' 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

Extension Methods in Dot Net 2.0

2010-03-05T12:57:45-06:00:00

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

2010-03-03T14:07:05-06:00:00

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

2010-02-22T16:30:45-06:00:00

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

2010-02-15T20:50:58-06:00:00

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