Ryan Farley's Blog : Development, .NET Extensions

Creating SalesLogix .NET Extensions with the .NET Extensions Helper Library

Ryan Farley — Thu, 27 Oct 2011 16:00:00 GMT

A couple of weeks ago I announced the .NET Extensions Helper open source library. I figured it was time for a more complete walkthrough so this post will show a video of how to get the library and use it to embed a .NET UserControl on a SalesLogix account tab. Let's take a look.

Demonstration of the .NET Extensions Helper Library

In this video you'll see how to get the .NET Extensions Helper library and how to use it to embed a .NET UserControl in SalesLogix.

Watch the Creating SalesLogix .NET Extensions with the .NET Extensions Helper Library on YouTube
The video will open on youtube.com in a new window

Take It For A Whirl

So, there will be more coming in future posts about the .NET Extensions Helper library. I'll cover how to wire up callbacks to invoke VBScript methods in the SalesLogix plugin from your .NET Extension and creating dialogs as well. For now, give it a try and let me know what you think.

Announcing the Open-Source SalesLogix .NET Extensions Helper Library

Ryan Farley — Fri, 14 Oct 2011 00:20:00 GMT

If you're working in the SalesLogix Windows (LAN) client, why not make as most use as possible of a modern development environment, language, and tools? The SalesLogix .NET Extensions feature in the SalesLogix Windows client is one of the best, and likely least used, features in the SalesLogix Windows client development story. A choice bewteen using an out-dated development environment and VBScript, with no possibility of using source control or a true multi-developer experience verses using Visual Studio, with source control, a modern language and framework where the sky is the limit? I'll take the latter any day. Still not convinced? The .NET Extensions Helper library comes to the rescue. This new open source project from Customer FX will make embedding .NET controls in SalesLogix a breeze.

Overview & How To Use

The .NET Extension Helper is a library that will do all the heavy lifting to embed controls in SalesLogix. All you do is have your UserControl inherit from the FX.SalesLogix.NetExtensionsHelper.SalesLogixControl and then use a script class in SalesLogix to load the control and set the record context.

Let's consider a very simple example of a .NET Control on an Account tab. You want to display the current account's contacts in a grid on this tab. Your .NET UserControl code will look something like this:

public partial class UserControl1 : FX.SalesLogix.NetExtensionsHelper.SalesLogixControl
{
    private void UserControl1_SalesLogixRecordChanged(string RecordID)
    {
        using (OleDbConnection conn = new OleDbConnection(this.SlxApplication.ConnectionString))
        {
            conn.Open();
            using (OleDbDataAdapter da = new OleDbDataAdapter(string.Format("select lastname as LastName, firstname as FirstName, type as Type from contact where accountid = '{0}'", RecordID), conn))
            {
                DataTable table = new DataTable();
                da.Fill(table);
 
                dataGridView1.DataSource = table;
            }
        }
    }
}

So, what are we looking at here? Basically, there's extra code in that example that opens an ADO.NET connection to the SalesLogix database and gets a DataSet to bind to a DataGridView, but the important parts there is that the UserControl inherits from a special base class named "SalesLogixControl" and then wires up an event called SalesLogixRecordChanged which passes in the current record's ID value. Whenever the record changes in SalesLogix, this event is fired and you're passed the record ID. Simple.

The above is the .NET side of things. There's only two lines of code needed in SalesLogix to drive this. In the example we have above, the SalesLogix form (the actual form in SalesLogix hosting this control), would include the following code:

'Including Script - System:ExtensionControl Class
option explicit

Dim ext

Sub AXFormOpen(Sender)
    Set ext = new ExtensionControl
    ext.Load "SampleExtension", "SampleExtension.UserControl1", Form.HWND, True
End Sub

Sub AXFormChange(Sender)
    ext.CurrentID = Form.CurrentID
End Sub

The code above simply includes a VBScript plugin named "ExtensionControl Class". Then, in the form's Open event it creates an instance of the ExtensionControl class and then tells it which .NET Extension to load, and passes the Windows handle (HWND) of where to embed the control (in this case it passes the handle, or HWND of the form itself). The "True" at the end tells it to resize the control to fill all available space in that area. When the record changes, it passes that into the class which fires the event in your .NET UserControl. That is it.

What you'll end up with is this:

There are other things available as well which you can make use of, such as passing a Subroutine from your VBScript to the .NET UserControl as a callback function. I'll discuss more about that later.

One of the biggest benefits you'll have when using this, and .NET Extensions in general, is that you'll get to use Sublogix for all data access which will drastically speed up development time. I've been working with a customer where we've been building out their SalesLogix Windows client using exclusively .NET Extensions and this library with Sublogix and it's actually been enjoyable to work with. I've not been this happy working in the Windows client, well, ever.

Where Can You Get It?

All code for this is on github as an open source project. You can grab the .NET assembly and associated SalesLogix bundle from there and start rolling. I'll try to put together a sample video of how to go from download to first use next week.

Visit the NETExtensionHelper home on github
Grab everything you need, the assembly, the SalesLogix bundle, and a sample project from the Downloads section.

Best Of All, It's Open Source

As I mentioned above, this is an open source project. If you're using .NET Extensions and have some good ideas to add, I'd love to see some contributions. Just clone the repository, make some changes and then submit a pull request.

Public SalesLogix Developer Classes Revamped

Ryan Farley — Mon, 27 Oct 2008 23:51:00 GMT

I announced a while ago that we will be offering some public developer training classes for SalesLogix Web. We will be making some changes to the class outline I posted earlier.

The new classes we will be offering will be as follows:

Building Solutions for SalesLogix Web
This is the all-inclusive web developer class that uses the concept of building a complete solution to train around. We will go from start to finish in building a solution that covers all typical development scenarios when developing for SalesLogix Web.
Process Orchestration
This is a full class that will focus on working with and developing for process orchestration (Windows Workflow) with SalesLogix 7.5 (Web or LAN).
SData & Integration
This class will focus on building solutions using the SalesLogix SData & REST services layer for both reading SalesLogix data and writing to SalesLogix (creating new records, updating, & deleting), focusing on integration and external application scenarios.
SalesLogix .NET Extensions
This class will focus on developing .NET Extensions for the SalesLogix v7 and higher LAN client. We will take an in-depth look at building, debugging, & managing .NET Extensions as well as look at cases when to use .NET Extensions vs. standard SalesLogix customizations.
Beginning C# & .NET Development for SalesLogix
We are also considering a "Beginning C# for SalesLogix" class that will cover the basics of C# and the .NET Framework from the perspective of working with SalesLogix.

I will be posting the complete class outlines and schedules to this site & RSS feed shortly. Stay tuned.

Ping a Remote Server Using C#

Ryan Farley — Thu, 22 May 2008 04:30:00 GMT

In my last post, I shared some code in VBScript to PING a remote server to check for availability before attempting to use a resource on that remote server. This wouldn't be my blog if I didn't also share this code in C# as well. IMO, this sort of thing is a far better suited for a .NET Extension if for the SalesLogix Windows client.

To perform a PING using C#, the code is far more straight forward than the VBScript version. No need for shelling the command out and reading back the StdOut. This version reads much nicer:

using System;
using System.Management;

namespace FX.Network.Utility
{
    public class NetworkDiscovery
    {
        public NetworkDiscovery() { }

        public static bool Ping(string Target)
        {
            SelectQuery query = new SelectQuery("Win32_PingStatus", string.Format("Address='{0}'", Target));
            ManagementObjectSearcher searcher = new ManagementObjectSearcher(query);

            foreach (ManagementObject result in searcher.Get())
            {
                return (result["StatusCode"] != null && (0 == (UInt32)result["StatusCode"]));
            }
            return false;
        }
    }
}

Enjoy!

How to Debug a SalesLogix .NET Extension

Ryan Farley — Mon, 20 Aug 2007 19:13:00 GMT

The question of how to debug a .NET Extension has come up a few times in the SalesLogix Business Partner newsgroups as well as on the slxdeveloper.com forums. I've answered this a few times in those locations, so this might be a repeat of info for some, but I did think it was worthwhile to post again here as well.

Here's a step by step to debug your SalesLogix .NET Extension:

Create your .NET Extension and compile it in debug mode
Add it to the Extension Manager and add whatever scripts to launch it
While the project is open in VS, go to "Debug" and then "Attach to Process".
Find "SalesLogix" on the list of running processes. Select it and then use the "Select" button to ensure that you've chosen to debug "Managed".
Set a break-point in VS in your code
Run the script that uses the extension and it will stop at your break-point.

Have fun!

SalesLogix and .NET in Version 7

Ryan Farley — Thu, 13 Apr 2006 22:22:00 GMT

The next version of SalesLogix (v7) will include support for executing .NET 2.0 code in SalesLogix. You run code from .NET assemblies, load forms into SalesLogix, and just about anything else. This is an awesome addition to SalesLogix for the developer that wants to get outside the “Architect box”. Here's a short sample (I'll be posting a lot more of these, but I need to make sure I won't get in trouble with any non-disclosures and beta agreements):

In Visual Studio 2005

using System;
using System.Windows.Forms;

namespace SLXNetTest
{
    public class Class1 : Sage.SalesLogix.LAN.WinForms.BaseRunnable
    {
        public override object Run(object[] Args)
        {
            string msg = "Hello .NET-SalesLogix World!\r\n\r\n" + 
                         "Argument passed: " + 
                                             (Args.Length == 0 ? "None" : Args[0].ToString()) + "\r\n" + 
                         "Current userid: " + SlxApplication.BasicFunctions.CurrentUserID() + "\r\n" + 
                         "Connection String: " + SlxApplication.ConnectionString;
            
            MessageBox.Show(msg, ".NET MessageBox");
            return null;
        }
    }
}

We'll compile that and add it to SalesLogix via the new .NET Forms Manager.

In a SalesLogix VBScript

Application.Managed.Run "SLXNetTest", "SLXNetTest.Class1", "Some argument"

Now Run the script and...

While this really does rock, it doesn't stop there. Loading .NET forms into the client. Forms, replacements for things like the account detail screen, passing values to the .NET code and back to the calling script, etc. Granted you could do all of this before (I've been doing this stuff in projects for years) but the best part of all of this is that the .NET stuff you add to SalesLogix can be bundled and will all synch out to remotes. Awesome stuff.