Ben Galluzzo

Code Camp NYC 2016 - MongoDB for Developers

Sat, 08 Oct 2016 05:38:00 +0300

Code Camp NYC 2016 Presentation

MongoDB For Developers And Accessing MongoDB data

This is where .NET, MongoDB, and SSIS meet. We'll begin with an overview of what MongoDB and NoSQL are and how it is often used in the world. Then, we'll go over some of terminology of MongoDB and how these terms map to the SQL world. Lastly, we'll demonstrate how we can work with MongoDB from SSIS using .NET code to make all of the connections.

CodeCampNYC_2016_MongoDB_Intro.pptx (1.05 mb)

Windows 8 Camp

Mon, 18 Mar 2013 20:31:00 +0300

This past Saturday, Microsoft hosted a Windows 8 Camp at Harrisburg Area Community College (HACC) on the Harrisburg campus. If you get the opportunity, take advantage of one of these free events offered by Microsoft. They provide for a good way to keep abreast of newer technologies and connect with fellow developers. Listed down below are links for you to keep tabs of some of the local development events.

The Windows 8 Camps are a great learning experience. Right now, if you haven't noticed, there's quite a change in how people stay connected and work with computer technologies. Tablet sales are projected to surpass PC sales this year so how users interact with the software which developers build is changing considerably. In some ways, end users of current technologies sometimes seem to be more in tune with these changes than even seasoned developers.

The focus of this camp was right in line to help existing .NET developers get in sync with the new Windows paradigm shift. Also, Microsoft kindly supplied breakfast munchies and a lunch. Chris Gomez @SpaceShot and Microsoft MVP John Baird @jbaird_pa gave tag-team presentations and were both understanding of what it takes for an existing .NET developer to advance the new mindset and make the jump to Windows 8 app development.

Sessions

Building Windows Store Apps Using HTML5/JavaScript

The first session overviewed Building Windows Store apps using HTML5, CSS3, and JavaScript. Chris opened up by keying in on some of main features of Windows 8 user interaction and what is essential in making good applications interoperable within a Windows 8 environment. Basically this was to jump-start experienced developers with one of the more significant changes to the Microsoft development portfolio.

In order to understand what is to be accomplished, Chris presented a cursory review of the Windows 8 user experience and then did a code walkthrough of navigation, searching, controls, sharing, and async operations. If there's one thing you can take away from this, it's Microsoft's recommendation that interacting with WinJS will simplify developing Windows 8 apps when using HTML5, CSS3, and JavaScript . WinJS is simply a JavaScript, CSS, and HTML library that helps build Windows 8 controls that are not necessarily implemented in HTML5. However, you can still develop apps with HTML5/JavaScript without the use of WinJS.

Building Windows store Apps with XAML/C#

Next John jumped into Building Windows Store apps with XAML and C#. A good portion of the participants had already been developing in this realm, so this session was an easier jump to constructing Windows 8 apps. If you've been building .NET applications in XAML for sometime, whether it's Silverlight or WPF, your learning curve to getting a Windows 8 app running is actually going to be fairly quick.

Process Lifetime of Windows 8 Apps

The third session, Process lifetime of Windows 8 apps, was led by Chris. Certainly, anyone who's been running Windows over the years knows that being mindful of your available resources is important in ensuring that things run smoothly, and actively keeping tabs of what's running and killing any unnecessary processes is a part of daily computing. However, the intention with Windows 8 is a bit different. To get you in the right frame of mind, think how you've been computing these days with your smart phone or tablet. The perspective is that provisions for an always-on and available mentality is in place when interacting with Windows 8 apps. Chris went on to describe throughout his walkthrough how apps go through the suspend and resume process and how to maintain consistent application state for a user friendly experience.

Introducing the Windows Store

Lastly, John went into an overview of the Windows Store. If you've used Google Play or the Mac App Store, you understand this concept. The Windows Store is basically a distribution system which allows for developers to deliver their certified apps to consumers. John went over a list of details in using the Windows Store and performed a walkthrough of signing up and registering your app on the Store.

During this, he discussed details on:

        • Selling, price points, and getting paid
        • Advertising options
        • Beta options
        • Limited functionality and timed trials
        • Registration
        • Application Certification Kit (ACK)
        • Localization
        • Deploying apps for use in other countries
        • Updates and versioning

Wrapping Up

As with any other nice event there was a little bit of SWAG and closing with a bunch a nice prizes. Again, keep tabs on your local events. The most important thing you can do is to meet other developers and possibly form ongoing relationships in your field. Right now, there's a dramatic change taking place in personal computing, and now's a great time to be part of that change.

Resources

Downloads, SDK’s, & Tools

Windows Store Apps Developer Downloads
includes the Windows 8 SDK, Blend for Visual Studio, Windows Application Certification Kit (ACK), practice labs, sample apps, and much more.

The Microsoft Windows Store

Windows 8 Camp in a Box - Official Microsoft Download Center
Lesson slides, the hands-on-labs, samples, and related resources.

Windows 8 Hands-on Labs Online (HOLO)
Scheduled live online presentations and labs. Experts are available in for real-time assistance through your lab work.

Windows Store App Labs

Event Calendars

Windows Camps Events Channel 9

Community Megaphone

Microsoft World Wide Events

Down-Convert an SSRS 2008 R2 RDL to SSRS 2008

Mon, 17 Dec 2012 05:02:00 +0300

Recently a team member brought up a problem in regards to obtaining a fairly sizeable 2008 R2 SSRS report which needed some modifications and to be deployed to a 2008 SSRS system; essentially requiring that the report RDL be down-converted to 2008 SSRS. Unfortunately, installing BIDS for 2008 R2 on this team member's development environment is not an option so there needs to be another way to provide for a 2008 version of this particular RDL for which to be modified. Could BIDS 2008 R2 on another developer workstation or a conversion utility provide the solution? Possibly. However, taking a look at the XML of the RDL, it's clear that the solution might be a bit simpler.

This solution should be able to be applied when converting from 2012 back to 2008 as well. Additionally, this may not be the most optimum method to update the RDL, however it was easy and quickly got a report out to production. One other detail to note is that this report allows for the ability to provide names to be assigned to each worksheet when it is exported to an Excel worksheet.

There are only two main steps to provide for this down-conversion:

Apply proper schema
Remove unsupported elements

Step 1 - Apply Proper Schema

To apply the older definition information, simply replace the newer RDL schema definition with the older version RDL schema. Find the SSRS 2008 R2 <Report> element:

<Report 
    xmlns:rd="http://schemas.microsoft.com/SQLServer/reporting/reportdesigner"
    xmlns:cl="http://schemas.microsoft.com/sqlserver/reporting/2010/01/componentdefinition"
    xmlns="http://schemas.microsoft.com/sqlserver/reporting/2010/01/reportdefinition"
>

Replace this <Report> element namespace information with the 2008 namespace information:

<Report
    xmlns="http://schemas.microsoft.com/sqlserver/reporting/2008/01/reportdefinition"
    xmlns:rd="http://schemas.microsoft.com/SQLServer/reporting/reportdesigner"
>

Step 2 - Remove Unsupported Elements

Remove incompatible start and end XML element tags. Look for and remove the following start and end elements if they exist; being sure to leave the data within the elements:

<ReportSections>
</ReportSections>

<ReportSection>
</ReportSection>

Look for and remove, if they exist, the following start and end elements as well as the data within the elements:

<PageName>...</PageName>
<Authentication>integrated...</Authentication>
<rd:SecurityType>Integrated</rd:SecurityType>

Finally, test within BIDS for SSRS 2008. That's pretty much all there is to it. One additional note, it's possible that there may be other properties within an SSRS 2008 R2 RDL that will balk in BIDS for SSRS 2008. Please feel free to share comments on any additional pieces of the RDL that may need to be removed or modified for a proper down-conversion.

Hide Tab Header of Tab Control

Wed, 07 Nov 2012 19:00:00 +0300

There are multiple ways in which the tab header of a tab control can be hidden. One way is to set the DrawMode of the control to "OwnerDrawFixed," the SizeMode to "Fixed, " and then set the ItemSize to "0, 1" What's left is somewhat of an abandoned tab header. A little bit of fussing with the layout is then required to clean up the tab control.

Another method is to extend the WinForm tab control and override the WndProc method to trap the TCM_ADJUSTRECT message, which is sent when it needs to adjust the size of the tabs, while the control is in DesignMode. This allows for a nice way of completely eliminating the tab header from the control without any need to clean up the layout. Once you trap the TCM_ADJUSTRECT message, return the value 1 to specify that the message was handled.

        if (_message.Msg == TCM_ADJUSTRECT && !DesignMode)
            _message.Result = (IntPtr)1;

While you're at it, put the class inside your custom library and add it the Visual Studio Toolbox so it can dragged onto a form whenever it is needed.

using System;

using System.Windows.Forms;

namespace StoreLib
{
    public class NoHeaderTabControl : TabControl
    {
        private const int TCM_ADJUSTRECT = 0x1328;

        protected override void WndProc(ref Message _message)
        {
            if (_message.Msg == TCM_ADJUSTRECT && !DesignMode)
                _message.Result = (IntPtr)1;
            else
                base.WndProc(ref _message);
        }
    }
}

References

Control.WndProc Method
TCM_ADJUSTRECT message (Windows)

Reading and Writing to an INI File in Managed Code

Mon, 13 Aug 2012 19:00:00 +0300

Due to the push for the adoption of XML configuration files, INI file handling was not built into the .NET Framework. However, INI files do still exist in legacy applications and can sometimes be found in newer software as well. So there needs to be a way to work with them from code. There are some available libraries, such as Nini and CommonLibrary.NET, which can perform this type of work, however, since this is part of the Quick-and-Dirty Series, here's a very simple example that will work for a lot of scenarios.

Interop Services to the rescue

Two kernel32.dll functions can be exposed to handle these INI files; WritePrivateProfileString and GetPrivateProfileString. The class IniFile listed below shows how to utilize these functions from Kernel32 via interop.

using System;
using System.Text;

using System.Runtime.InteropServices;

namespace StoreLib.Configuration.Ini
{
    public class IniFile
    {
        [DllImport("kernel32")]
        private static extern long WritePrivateProfileString(string _section, string _key, string _val, string _filePath);

        [DllImport("kernel32")]
        private static extern int GetPrivateProfileString(string _section, string _key, string _def, StringBuilder _retVal, int _size, string _filePath);

        public IniFile(string _path)
        {
            Path = _path;
        }

        //Write to INI File
        public void WriteValue(string _section, string _key, string _value)
         {
            WritePrivateProfileString(_section, _key, _value, Path);
        }

        //Read from INI File
 public string ReadValue(string _section, string _key)
 {
 StringBuilder sb = new StringBuilder(255);
 int i = GetPrivateProfileString(_section, _key, "", sb, 255, Path);

 return sb.ToString();
 }
        public string Path { get; set; }
    }
}

Once the IniFile class is ready, reading a value is easy:

IniFile iniFile;
iniFile = newIniFile(@"C:\LegacyApplication\la.ini");

string dataSourceKey = "source1";
string dataSourceName = iniFile.ReadValue("DataSources", dataSourceKey);

Similarly, writing a value to the file is just as easy:

IniFile iniFile;
iniFile = newIniFile(@"C:\LegacyApplication\la.ini");

string appLoadKey= "splash";
string appLoadValue = "logo";
iniFile.WriteValue("AppLoad", appLoadKey, appLoadValue);

That's all there is to it. This is just one option for accessing an INI file and should be able to handle most instances of a section's simple key-value pair. Feel free to give it a try.

___________

Quick-and-Dirty Series - Hopefully still a sound solution, these may not be the best, fastest, or most appropriate methods of accomplishing a development task, however, they work and are fast to put in place.

My .NET Development Environment Toolset

Sun, 11 Sep 2011 22:00:00 +0300

By all means, this is far from a complete list of my .NET development toolbelt. It is just a select few of effective lightweight utilities that I commonly use. Often said, although there is often a better tool for the job, sometimes the best tool for the job is the one you know. Please feel free to share some of your own favorites.

Productivity & Desktop

dnGREP

Developing and working within Unix (I often date myself by typing UNIX) and Linux environments, I've learned to really appreciate some of the great shells and commandline utilities. One of my favorite utilities was grep, which is a text searching utility. dnGrep is a Windows implementation of this utility.

http://code.google.com/p/dngrep/

Cygwin Bash Shell

Tee'ing off of the previously stated usefulness of the Unix command shells, Cygwin is a port of many of the more popular Unix tools and provides commandline interaction of these utilities.

http://www.cygwin.com/

Focus Booster

This is just one of a dozen-dozen utilities assisting with the Pomodoro Technique. This is just one that I like because it's simple, clean, and small. That's kind of a theme of mine when it comes to maintaining my development toolbelt.

http://www.focusboosterapp.com/

If you want to learn more about the Pomodoro Technique have a look here: http://www.pomodorotechnique.com/ Obviously, this isn't the end-all be-all of productivity methods. There may another one that's a better fit for you.

Input Director

Multiple computers, multiple monitors, one keyboard, one mouse. There's nothing that keeps my desk cleaned up and my hands in one place better than this productivity tool.

http://www.inputdirector.com/

notepad

Maybe overstating the obvious, but notepad is one of my more useful tools as well. Often I'm on a system without a good toolset and need to remove any textual formatting from any text that's block copied. While my development machines have various utilities for pasting cleaned up text, that system on the other end of the network probably will not.

ImgBurn

As often, simple is always better. I've created so many less coasters over the years with this CD/DVD burning/copying utility than with any other tool.

http://www.imgburn.com/

FormatFactory

This is a just a great media converter. It's been very effective for me and is one of the few that doesn't bog down my workstation.

http://www.pcfreetime.com/

Graphics & Images

Paint.NET

This is probably my alltime favorite graphic editor. It is such a capable image editor and has a large following with which to collaborate.

http://www.getpaint.net/

Greenshot

Greenshot is a speedy lightweight screenshot tool. I'm hesitant to keep anything running in my windows taskbar that I don't need at all times and is going to use up a lot of memory. These kind of utilities are notorious for sapping away more memory than they need while waiting for you to use them. Greenshot is not one of them and has a home in my taskbar.

http://getgreenshot.org/

Wordpad

Did I hear a laugh? Yes, as funny as it sounds. Often I need to get full or partial screen shots on systems that don't have much of anything in terms of productivity tools installed on them. I sometimes need to gather a few simple screen shots and to move on. I've found that it's quicker, and tidy, to just drop a bunch of images in a Wordpad document and then wrap things up elsewhere.

Reporting

RSScripter

Although, it can be done from a manual sense, I often need to grab a load of SSRS reports from a server to either be moved or worked on. This little utility is great for short work of these operations.

http://www.sqldbatips.com/showarticle.asp?ID=62

Report Builder

I often say that developers are lazy. They only want to type something once, automate things, and build things that, in turn, build things for them. Every once in awhile a dynamically generated report doesn't fit the bill and a one-up report is needed. I don't want to take up time with a project, I just want to get the information out there into a report format as quickly as possible. Better yet, if all of the work is done in a stored procedure and available to the report definition, I only need to worry about the layout, groupings, etc. of the report.

http://www.microsoft.com/en-us/download/details.aspx?id=6116

Internals

Dependency Walker

This great utility by Steve Walker examines Windows assemblies and provides realtime interactive diagrams of any activity, errors, and interactions between the different modules running on your system. While it provides extremely detailed useful information, it is surprisingly intuitive for the uninitiated.

http://www.dependencywalker.com/

Sysinternals

Ever since I first purchased the Winternals suite of admin tools years ago, I've been a satisfied customer. This suite of small and effective utilities are use for monitoring and managing Windows systems. Microsoft later obtained Winternals and still has the majority of the tools available for free. I often create scripts or shell commands to the various utilities. Process Explorer, TCPView, PsService, PsList, PsKill, PsInfo, PsExec are the utilities I make use of on a regular basis.

http://technet.microsoft.com/en-us/sysinternals/bb842062

Development/Debug

Firebug

This is a Firefox plugin that provides a more detailed view of HTML, CSS, and JavaScript from the client.

http://getfirebug.com/

Glimpse

This is an ASP.NET diagnostics tool that captures performance characteristics for further debugging or troubleshooting. It has the ability to gather an amazing amount of detail fairly easly.

http://getglimpse.com/

JustDecompile

Reflector used to be my go-to tool for .NET code decompilation. This has been an incredible useful tool. Not long after Reflector became a premium product, JustDecompile from Telerik came on the scene.

http://www.telerik.com/products/decompiler.aspx

FXCop

FXCop is tool that helps maintain that certain rules pertaining to security, naming conventions, proper memory usage, and design are met within .NET code.

http://msdn.microsoft.com/en-us/library/bb429476(v=vs.80).aspx

Setting Up Debug Mode for a Windows Service Project

Fri, 14 Jan 2011 17:36:00 +0300

If you’ve tried to run a Windows Service project in debug mode, you’ve probably seen the message shown below. To debug our code by default, we would have to install the service and then attach the debugger to a Process (Ctrl+Alt+P). Obviously, this can get tedious. There is a more appropriate and efficient way to debug the Windows Service project in which we’re developing.

Let’s start out by constructing a simple Windows Service… Add a Windows Service class item to the project; in our case, the class is named AgentService.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Linq;
using System.ServiceProcess;
using System.Text;

using System.Timers;

namespace ProvingGrounds.Agent
{
    partial class AgentService : ServiceBase
    {
        private Timer timer = null;

        public AgentService()
        {
            InitializeComponent();

            timer = new Timer(6000);
            timer.Elapsed += new ElapsedEventHandler(timer_Elapsed);
            timer.Enabled = true;
            timer.AutoReset = true;
        }

        protected override void OnStart(string[] args)
        {
            Start();
        }

        protected override void OnStop()
        {
            Stop();
        }

        public void Start()
        {
            timer.Start();
        }

        public void Stop()
        {
            timer.Stop();
        }

        void timer_Elapsed(object sender, ElapsedEventArgs e)
        {
            //TODO:Do Something
        }
    }
}

Next, update Main() found in Program.cs to execute AgentService.

        static void Main()
        {
            ServiceBase[] ServicesToRun;
            ServicesToRun = new ServiceBase[] 
			{ 
				new AgentService() 
			};
            ServiceBase.Run(ServicesToRun);
        }

We should now have our Windows Service constructed. Feel free to compile it and then go ahead try running it in debug mode. You should be receiving our "Start Failure" error message.

Next, let's get this thing running in debug mode from Visual Studio. We can do this by adding the #if DEBUG preprocessor directive to our Main() function. We simply wrap the existing call to our AgentService with the conditional preprocessor directives.

using System;
using System.Collections.Generic;
using System.Linq;
using System.ServiceProcess;
using System.Text;

using System.Threading;

namespace ProvingGrounds.Agent
{
    static class Program
    {
        static void Main()
        {
            #if DEBUG
            
            AgentService agentService = new AgentService();
            agentService.Start();

            Thread.Sleep(Timeout.Infinite);

            agentService.Stop();

            #else

            ServiceBase[] ServicesToRun;
            ServicesToRun = new ServiceBase[] 
			{ 
				new AgentService() 
			};
            ServiceBase.Run(ServicesToRun);
            
            #endif
        }
    }
}

That's all there is to. Go ahead and hit F5 from Visual Studio and your Windows Project should be running in Debug Mode.

Rounding-Out A Class Library – Extension Methods

Mon, 01 Nov 2010 16:57:00 +0300

One potential improvement to a custom class library could lie in the use of extension methods. In short, extension methods are a quick and simple way to extend a type without modifying or recompiling the actual type which is being extended. Utilizing an extension method is as simple as calling the ToString() method on a type. At first it may seem difficult to come up with uses for extension methods. However, working through a project, potential use for an extension method may present itself and also could very well reside in commonly created utility classes. Operations often performed against a type in the same context is a perfect use for converting a utility function into an extension method.

Defining an extension method might seem a little odd at first to the uninitiated. Take a bit of time to think about what’s happening under the hood to provide this added functionality, automatically, to an existing type. The first parameter of an extension method takes on the this modifier to accept the type on which the method operates. Utilizing the extension methods requires adding a using directive of the namespace for which the extension method resides.

Below are a couple very simple examples of extension methods and their use. These two extension methods provide a boolean value for a check of a null value or an empty value against an Array type and also a for String type.

using System;

namespace ProvingGrounds.Lib
{
    public static class LibraryExtensions
    {
        public static bool IsNullOrEmpty(this Array _value)
        {
            return (_value == null || _value.Length == 0);
        }

        public static bool IsNullOrEmpty(this string _value)
        {
            return (_value == null || _value.Length == 0);
        }

    }
}

Utilizing these new extension methods can only be done if applying the proper using directive to the calling class; in this case, using ProvingGrounds.Lib.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using ProvingGrounds.Lib;

namespace ProvingGrounds.Console
{
    class Program
    {
        static void Main(string[] args)
        {
            string emptyTest = null;
            if (emptyTest.IsNullOrEmpty())
                System.Console.WriteLine("emptyTest is null or empty");
        }
    }
}

Omitting the proper using directive will result in the extension method not being available for use.

Care should be taken when enabling more global usage. For instance, if the class housing the extension methods are added to the System namespace, their use can be made more readily available.

using System;

namespace System
{
    public static class SystemExtensions
    {
        public static bool IsNullOrEmpty(this Array _value)
        {
            return (_value == null || _value.Length == 0);
        }

        public static bool IsNullOrEmpty(this string _value)
        {
            return (_value == null || _value.Length == 0);
        }

    }
}

So there it is. A couple of very simply extension methods in practice. Have fun with them. Use them to simplify often used operations on types; operations whose functionality may already reside in common util classes.

Utilizing table variable and while loop to avoid cursor-style operations

Fri, 07 May 2010 17:57:00 +0300

So, here is one of many scenarios in which the work performed can be accomplished by use of a cursor. For a long running set of queries such as what's listed below, utilizing a cursor could have undesired painful effects such as blocking. In a tough spot, those who look toward a procedural approach in SQL often quickly jump to using cursors.

Here the scenario is described. There are two dissimilar systems. The first is the old system which will still be in production for an indefinite period of time. The old system is actually comprised of multiple systems on multiple SQL servers; one for each client. The second, the replacement system, is running along side the old system and is managing different data of the same type of business process. Specific work data is to be retrieved from the old system and married to the work data being retrieved from the new system so team leads can keep tabs on the work data without going to both systems.

It's actually fairly easy to utilize a table variable and a while loop to avoid these cursor-style operations. Here is an example of a very simplified operation to obtain the related client data from the older system in preparation for marrying it to the related client data from the new system. This example also briefly looks at a way to generate dynamic SQL. There probably is a better way to do this type of work, but it is indeed easy enough for most to be able to wrap their mind around.

The key pieces of the query are the table variable containing the list of client databases, an iterator, a total row count variable, and the while loop.

The table variable, of course, will only persist in the life time of the SQL connection. Once the query has completed, the table variable is gone. Creating the table variable with an auto-incrementing integer identity field provides for the ability to actually loop through the work list.

DECLARE @clientData table (                      
    RowNum int IDENTITY (1, 1) Primary key NOT NULL,                      
    ClientID uniqueidentifier,          
    ClientName varchar(100),               
    ClientSource varchar(50)  --location of old system
)

Now, populate the temp table with all of items for with which to work. Next, is the preparation of the variables to be able to run through the loop properly.

DECLARE @rowCount int                      
DECLARE @maxRows int                    
                      
SELECT @rowCount = 1            
          
SELECT @maxRows = count(*) from @clientData          
PRINT @maxrows

Then the loop is built; being sure that the @rowCount variable is incremented by one for the next return back through the loop. Note how the current temp table row data can be accessed for use inside the loop.

WHILE @rowCount <= @maxRows                      
BEGIN              
    DECLARE @clientID uniqueidentifier          
    SET @clientID = (SELECT ClientID FROM @clientData WHERE rowNum = @rowCount)          
        
    DECLARE @clientName varchar(100)          
    SET @clientName = (SELECT ClientName FROM @clientData WHERE rowNum = @rowCount)          
              
    DECLARE @sourceName varchar(50)                      
    SET @sourceName = (SELECT ClientSource FROM @clientData WHERE rowNum = @rowCount)                      
          
    DECLARE @sql varchar(4500)          
          
    SET @sql = '          
    INSERT INTO WorkList          
    SELECT
        '''+@clientID+''' ClientID,
        WI.create_date CreatedDate,       
        '''+@clientName+''' Client,          
        ....
        ....
        ....
        ....
        ....
        ....
        ....
    LEFT JOIN          
        ' + @sourceName + '.dbo.WorkItem WI
    ON          
    '                            
    EXEC SP_EXECUTESQL @SQL
          
    SELECT @rowCount = @rowCount + 1   
END

To provide the big picture, here is the query in its entirety.

-------------------------------------------------------          
-- Begin - Obtain client list          

DECLARE @clientData table (                      
    RowNum int IDENTITY (1, 1) Primary key NOT NULL,                      
    ClientID uniqueidentifier,          
    ClientName varchar(100),               
    ClientSource varchar(50)  --location of old system
)                 
          
INSERT INTO @clientData (ClientID, ClientName, ClientSource)          
SELECT          
    C.ID ClientID,          
    C.[Name] ClientName,            
    '[' + M.cServer + '].' + M.cDatabase ClientSource              
FROM [ModernServer].CoreClient.dbo.Client C
LEFT JOIN Mapping.dbo.Client M
ON C.MappingClientID = M.cID                  
WHERE C.IsActive = 1                      
          
-- End - Obtain client list          
-------------------------------------------------------          
          
-------------------------------------------------------                                  
-- Begin - Create temp table                                  
                                  
IF object_id('WorkList') IS NOT NULL                                  
BEGIN                                  
    DROP TABLE WorkList
    PRINT 'Table Dropped'                                  
END                                  
                                  
CREATE TABLE WorkList (
    ClientID uniqueidentifier,
    CreatedDate datetime,    
    ClientName varchar(100),
    CreatedByName varchar(100),          
    ProblemCode varchar(50),          
    CustomerName varchar(100),          
    AccountNumber varchar(50),          
    StatusType varchar(25),
    LastUpdateDate datetime,
    UpdatedByName varchar(100)
)                                  
     
-- End - Create temp table                               
-------------------------------------------------------           

DECLARE @rowCount int                      
DECLARE @maxRows int                    
                      
SELECT @rowCount = 1            
          
SELECT @maxRows = count(*) from @clientData          
PRINT @maxrows
          
WHILE @rowCount <= @maxRows                      
BEGIN              
    DECLARE @clientID uniqueidentifier          
    SET @clientID = (SELECT ClientID FROM @clientData WHERE rowNum = @rowCount)          
        
    DECLARE @clientName varchar(100)          
    SET @clientName = (SELECT ClientName FROM @clientData WHERE rowNum = @rowCount)          
              
    DECLARE @sourceName varchar(50)                      
    SET @sourceName = (SELECT ClientSource FROM @clientData WHERE rowNum = @rowCount)                      
          
    DECLARE @sql varchar(4500)          
          
    SET @sql = '          
    INSERT INTO WorkList          
    SELECT
        '''+@clientID+''' ClientID,
        WI.create_date CreatedDate,       
        '''+@clientName+''' Client,          
        ....
        ....
        ....
        ....
        ....
        ....
        ....
    LEFT JOIN          
        ' + @sourceName + '.dbo.WorkItem WI
    ON          
    '                  
          
    PRINT (@SQL)
    EXEC SP_EXECUTESQL @SQL
          
    SELECT @rowCount = @rowCount + 1   
END

That's all there is to it. This is just one example of so many others to use a temp table or table variable and while loop in lieu of a cursor.