While there are some guides available that give you similar information, I found it a bit difficult to get started developing MVC modules in DNN. For reference, the articles I used are at the bottom of this blog.

Here’s an overview of the steps we’ll take to get started.

1. Prerequisites
2. Templates
3. Setup
4. Build
5. Installation
6. Next Steps
7. References

1. Prerequisites

For this quick start, you’ll need a few things before we can dive in.

First, you’ll need to have Visual Studio 2015 installed. The express editions have been reported to be incompatible with the templates we’ll be using later, but this may not be true by the time you’re reading this.

Next, you’ll need to have IIS (Internet Information Services) setup with a local installation of DNN (version 8 or higher). There are many tutorials on how to do this around the web. You’ll need to install IIS and Microsoft SQL Server, then you can install DNN by downloading the latest _install.zip from DNN’s GitHub releases.

Once those are all set up, you’re ready to go.

2. Templates

You could create a module from scratch. But why would you do that when a DNN expert created templates for you to use? Download the templates from the Visual Studio Gallery and run through the installation procedure.

3. Setup

Now that everything is set up, we can actually dive into creating the module. 

In Visual Studio, select File -> New -> Project

In the New Project window, select Templates -> Visual C# -> DotNetNuke and you’ll see a listing of the types of projects the templates have provided.

To create an MVC module, we’ll select DotNetNuke 8 C# DAL2 MVC Module. There are three other fields we must configure: Name, Location, and Solution name.

Name: Enter a name for your project (it’s best not to use any spaces or special characters for this)

Location: This is important to point this to the correct folder in DNN: /DesktopModules/MVC/. Depending on your installation directory, the folder should be something like C:\Dev\Projects\DMC_Website\Alpha\DesktopModules\MVC\ where “Alpha” is the root of your DNN installation.

Solution name: We’re not actually going to be using this field. Uncheck the box on the right that says “Create directory for solution” and the solution name textbox will be greyed out.

Confirm your settings look similar to mine and then click OK.

A Project Setup Wizard dialog box will appear asking for some project information. Many of these are self explanatory, so I will only address the two that are a bit tricky.

Namespace: Whatever namespace you want your module to live in. The templates will automatically include your project name in the namespace, so no need to enter it here. Make sure you include the last period. E.g. DMC.

Local Dev URL: By default this is set up to point to dnndev.me, which is actually set up to point back to 127.0.0.1 (your localhost). What you enter here depends on what settings you’ve set your DNN install up with. For my installation, I access my local DNN install through http://localhost./ Therefore, I am going to enter localhost as my Local Dev URL.

Initial values

Updated values (note: the owner website field includes https:// but the textbox isn’t large enough to display it. Be sure to include it in your URL.)

Once all fields have been complete, click OK.

4. Build

Now that the initial project setup is complete, you’ll be presented with a web page in Visual Studio that says * Important *. These are steps that you should read carefully and follow to ensure your project will work correctly. I’ll provide a quick overview of these steps in case the original wording is confusing for anyone.

First, check IIS to see if any of your folders were converted to virtual directories or applications. To do this, open IIS, expand your site’s dropdown and check what icon is displayed next to your DesktopModules folder or the MVC folder inside of the DesktopModules folder. If it’s anything other than a yellow folder, right click it and click remove.

Next, in Visual Studio, right click and delete the web.config files that are in the solution.

You can now build the module! change the solution configuration dropdown from Debug to Release and then select Build -> Build

You’ll get an install .zip file in your module’s install/ directory.

5. Installation

Now, in DNN, go to Hosts -> Extensions and click Install Extension, selecting your install .zip file that you previously built.

If everything goes well, then the module is now installed and can be placed on any page.

6. Next Steps

Once you’ve dragged the module into a page, you’ll see a demo application that includes multiple views, database interaction, and more. Simply build the project in debug mode to automatically copy the new DLL to the /bin folder.

7. References

• Chris Hammond’s DNN posts
• DNN Community Blogs
• DNN MVC Module Development

While you’re here, check out DMC’s Web Application Development and ASP.NET & ASP.NET MVC Development services so we can get started on your next DNN MVC module!

The post 6 Easy Steps to Get Started with MVC Module Development in DNN 8 appeared first on DMC, Inc..

Fortunately, pulling data from the AD and using it in your application is much easier than you might think, and allows you to maintain data integrity by keeping your data in just one place. Also, SharePoint developers will be happy to learn that the AD can be queried from within a SharePoint add-in with the same code that I’ll be sharing here.

First, let’s have a brief review of what the Active Directory (AD) is:

The AD is, for the purpose being discussed here, basically a database, except that its storage is hierarchical in nature. The data it stores typically regards the different components in a computer network. For example, a very common use of the AD is to store various pieces of information about a user (email address, name, phone number, title/job description, etc.) It may also contain data about user groups, such as the marketing department, IT, etc.

Getting Started

The first thing you’ll need to do is figure out what your AD domain path is. Also, if you’re querying the AD from within a SharePoint add-in, you’ll need to make sure that the user under which the Add-in web service is running has the proper permissions to access the AD.

And finally, it should be said at this point that you’ll need to use a few .NET assemblies that you may have never touched before:

using System.DirectoryServices;

using AD = System.DirectoryServices.ActiveDirectory;
using AP = System.DirectoryServices.Protocols;
using AM = System.DirectoryServices.AccountManagement;

using System.DirectoryServices;

using AD = System.DirectoryServices.ActiveDirectory;
using AP = System.DirectoryServices.Protocols;
using AM = System.DirectoryServices.AccountManagement;

Example: Getting User Info

Something I often find myself having to do is get a list of all users in the AD, along with some piece of data associated with them. In this example, we’ll be building a Dictionary that associates each user with the name of their manager.

First, let’s show you the code, then we’ll explain it.

After we’ve declared an empty dictionary, and retrieved our current path, we go ahead and create an instance of the DirectoryEntry class, passing our domain path as a parameter to its constructor. It should be noted that most of these DirectoryServices classes implement the IDisposable interface, meaning that we need to make sure we dispose of them after we’re done using them. To make this easier, of course, we utilize “using” statements here, so that our unmanaged resources automatically get released.

Next, we pass our DirectoryEntry as a parameter to the DirectorySearcher class constructor. The DirectorySearcher class’ main purpose is to allow us to query the AD.

Now that we have our DirectorySearcher instance, the wise thing to do is to use a filter to narrow our search results – if we skip this step, we sacrifice performance. So we assign to the DirectorySearcher’s Filter property a string that represents an LDAP query. In this case, our query “(&(objectCategory=User)(objectClass=person))” returns only objects that are in the User category and that implement the “person” class.

Now, for a given AD object, there can be dozens or even hundreds of properties. So to save on performance, we only want our query to return those properties which we’ll actually be using. To do this, we add property names as strings to the PropertiesToLoad property of our DirectorySearcher. Finally, we execute the query by calling the FindAll method of the DirectorySearcher. This returns a SearchResultCollection.

Iterating through this collection gives us access to SearchResult class instances. To avoid a null reference exception, I like to ensure that each SearchResult actually has the properties that I’m looking for. After that, getting our values is a simple matter of accessing the Properties property of the SearchResult with a string indexer. In this case, both are properties are simply strings, so I only want to return element zero, but if the property I was querying were an array, I would probably be iterating through it or doing some other operation.

So the final step here is to add the value of our user’s display name and the value of the “manager” property as a KeyValuePair in my Dictionary, and move on to the next SearchResult. Once we’ve iterated through the entire collection, we can simply return our Dictionary.

Learn more about our Microsoft Consulting Services

The post Querying the Active Directory appeared first on DMC, Inc..

We’re seeing them more and more. Don’t get me wrong, off the shelf solutions are great, and should be used wherever they make sense. But sometimes they don’t fit all of the requirements our customers need. Here are some examples I’ve encountered over the past few months where a custom PC app made the most sense in an industrial setting:

1.    A program that automatically parses CAD drawings of a part, and then sends the resulting data to a PLC.
2.    Multiple offsite PLCs sending Ethernet packets over a cellular modem, to a server-side application that received, parsed, and logged the data.
3.    A web-based interface that translate data back and forth between a custom SQL server and multiple PLCs.

So we’ve established there are situations where a custom app makes sense. But how does one write this type of program? What tools are out there to connect the dots? As it turns out, there are plenty! Here are some of my favorites:

Dot Net PLC Toolbox 
Believe it or not, there’s actually a pretty strong community of .NET developers interested in interfacing to PLCs. One of my favorite open-source libraries is the Dot Net PLC Toolbox. This in-depth, free library allows .NET apps to parse PLC projects, as well as communicate, read tags, and go online. Last year I personally was involved with using this toolbox to create an open-source S7 Source Control Utility.

InGear Drivers 
The guys over at InGear have created easy-to-use .NET drivers for Siemens, OPC, and more. Sure, there are free tools available, but sometimes it’s nice to pay for a product just so you have a support team to rely on when you need them.

Jamod
Most of our development is built on .NET, but sometimes client requirements dictate another language like Java. This is where a library like Jamod can be handy. Jamod is a Java library written for Modbus (serial, TCP, or UDP). Since Modbus is such an open protocol, this library makes it easy to connect your Java application to PLCs, drives, smart IO, and more.

TIA Portal Openness 
For Siemens PLCs in particular, there are official tools available to the interested programmer. With the latest version of TIA Portal, Siemens released an API used to interface with PLC programs. This code library allows developers to “automate” their code development by exporting, modifying, and importing TIA projects. I was pretty familiar with their old software, the Command Interface, and was excited to see them release a tool for Portal as well.

Learn more about DMC’s .NET and automation intelligence capabilities. 

The post Connecting Custom Applications to the Factory Floor appeared first on DMC, Inc..

Sam, Sudeep, and I were fed up with this. On our latest FedEx Day, which is a day dedicated to fun, internal improvement projects, we decided there had to a better way. An advanced, easy-to-use team communication and collaboration tool that served a single, highly-specialized purpose: to figure out what we wanted to eat.

And since we’re a creative bunch, we made exactly that and named it Lunch for Business.

Application Features

It can be hard to get a large group of people all using the same new tool. That’s why our number one goal was to make this stupid simple. It installs with a single click, automatically launches on startup, and lives stowed away in your system tray.  

When you decide that yes, you would very much like a burrito today, you can double click the tray icon, type in “Chipotle”, and hit suggest. At that moment, everyone currently running Lunch for Business gets a little balloon notification saying that a suggestion has been made. People can then click “Join” to hop on your bandwagon, or they can make a suggestion of their own.

Once you’ve joined a lunch spot, you can let people know you’re willing to drive others there. You can also click on the lunch spot to launch Google Maps for directions and check out the traffic conditions. When you’re ready to go, you can click “Leave” and everyone in your group will get notified that it’s time to head out.

Lunch for Business was adopted quickly and has become the de facto way of suggesting places to go eat in the Chicago office. The days of walking around in circles are long gone. Aside from fulfilling an extremely important need, the project has been a nice way to check out cool technologies like SignalR, Hangfire, and the Google Maps API.

We also used a variety of familiar favorites to build the application, including:

• C#
• .NET
• WebSockets
• ASP.NET MVC
• WPF
• Microsoft SQL Server

A Closer Look at DMC's Noshing Preferences

As an added bonus, keeping track of lunch spots has let us keep statistics on where DMC likes to eat. Chipotle and Mariano’s dominate the list, with one of the two being suggested half of the time. But, thankfully, the other half includes a much more diverse list of places in our neighborhood. DMC clearly has some favorites, but we still like to explore different options.

Learn more about DMC's Custom Software and Hardware Development services.

The post Lunch for Business: A Better Way to Lunch appeared first on DMC, Inc..

We had a great summer here at DMC’s Chicago office. We got to watch the Air and Water Show at Belmont Harbor, go to the Circus, drink on a boat, and play some beach volleyball. However, for a .NET developer like me the real highlight of the summer was the release of Visual Studio 2015. VS2015 was released officially on July 20th, and over the past several weeks I’ve gotten a chance to dig into it and explore all of the great new features. This new version of Visual Studio includes many improvements ranging from cross-platform development tools to a major update in the ASP.NET platform. However, the features that I’ve been enjoying the most are the enhanced debugging and diagnostics tools.

Below are a few tips and tricks that I’ve learned about debugging in Visual Studio 2015 that I think every developer should know about:

LINQ Expressions in Debug Windows
LINQ expressions now work in debug windows. You may not have been aware of this limitation before, but all previous versions of Visual Studio did not allow for LINQ expressions within debug windows. So for instance if I wanted to do a quick LINQ query in my Watch list to narrow down a list of 100 elements to the few elements that I actually wanted to look at I couldn’t. Now I can!

LINQ expressions working great in Visual Studio 2015…

…not so well in Visual Studio 2013.

PerfTips
This was a feature I didn’t even know I needed until I had it. PerfTips give you in-line information about the performance of your code as you are stepping through it in the debugger. This makes it very easy to time how long the execution of a block or line of code is taking without having to deal with adding in debug timers and writing to the console. Its super simple and effective. You can also click on the PerfTip to bring up information about events and resource usage related to that PerfTip in the Diagnostics Tools Window.

PerfTips in action. In this case, we can see that it took 5 milliseconds to execute the previous line.

Diagnostic Tools Window
This is a brand new window that is useful for debugging performance issues while your application is running. The Diagnostic Tools Window makes it easy to observe the memory and CPU usage of your application by charting the resource usage on live charts. You can also take snapshots of your applications memory usage in a single click and then compare the snapshots to find memory leaks.

A series of memory snapshots taken in the Diagnostic Tools Window indicates that this program has a memory leak.

Live Visual Tree
Yet another brand new window in VS2015. This tool allows you to explore the visual tree of a XAML window (or HTML document) while the application is running. I’ve been using tools like WPF Inspector and Snoop in the past to accomplish UI debugging in WPF applications, but I always welcome the opportunity to use an integrated tool. If you are someone who is constantly tweaking user interfaces in XAML and trying to figure out why that MVVM binding isn’t working then you should definitely check this out.

The Live Visual Tree lets you explore the live XAML tree and easily trace down the source code for any element.

To learn more about Visual Studio and .NET check out other DMC blog posts or our Custom Software development services.

The post Visual Studio 2015 Debugging Tips appeared first on DMC, Inc..

Tools

• Ruby
• Sass (or Less)
• Node.js
• npm
• Bower
• Grunt or gulp

Ruby

We won’t be using Ruby as a programming language, but we will be needing it to install SASS.

If you’re on Windows, download the latest version of Ruby

If you’re on Linux or OS X, there are instructions you can follow

Or, after installing cURL, run this in a terminal window:

\curl -sSL https://get.rvm.io/ | bash

\curl -sSL https://get.rvm.io/ | bash

Once Ruby has finished installing, no matter what platform you’re on, open a terminal window and run

ruby -v

ruby -v

to ensure it has installed properly.

Sass (Syntactically Awesome Style Sheets) or Less

Sass is basically CSS with a ton of awesome features layered on top. Using Sass, which compiles to clean and efficient CSS, one can make use of extended abilities like variables, mixing, inline imports, and more.

There is another CSS extension called Less, which is an alternative to Sass. I prefer Sass, but you could definitely adapt this tutorial to work with Less as well.

Anyhow, now that Ruby is installed and ready to go, installing Sass is easy.

In a terminal window, type

gem install sass

gem install sass

Once that is finished, run

sass -v

sass -v

to ensure it has installed properly.

Node.js

Node.js is tool that allows one to write simple JavaScript programs that create powerful applications.

We’ll be using Node.js to power npm (node package manager), Bower, and Grunt.

Grab the proper download for your platform

To install Node.js on Windows or OS X, simply run the installers.

On Linux, you can build Node.js by using these steps:

Extract the downloaded archive and open a terminal window

1. Navigate to where you extracted the archive

2. Run

./configure

./configure

3. Run and wait patiently

make

make

4. Run

sudo make install

sudo make install

And you’ll be all set with Node.js.

npm

npm is the official package manager for Node.js. What this means is that using npm, one can install hundreds of different applications and tools that are built with Node.js.

We’ll be using npm to install Bower and Grunt.

npm comes installed with Node.js, so there are no additional steps required to install it.

Bower

Bower, much like npm, is a package manager. However, npm only deals with Node.js packages while Bower titles itself “a package manager for the web.” Using Bower, one can run a simple terminal command to download and install many different web libraries or frameworks, such as jQuery, Bootstrap, FontAwesome, and more.

To install Bower, open a terminal window and type:

npm install -g bower

npm install -g bower

(The -g flag is to install bower globally, so we can call it from the command line anywhere)

Grunt or gulp

Grunt is a task runner that performs the time-consuming, repetitive tasks that come along with website development like minification, SASS compilation, and more. 

Thanks to npm, Grunt is just as easy to install as Bower:

npm install -g grunt-cli

npm install -g grunt-cli

gulp (don’t you ever capitalize that g) is a similar tool that should provide better performance than Grunt because it uses Node.js’s streams.

npm comes in handy once again. Install gulp with:

npm install -g gulp

npm install -g gulp

Beginning Automation

Now that we have all of the tools we need to begin, we can finally start creating an automated build system.

There are tasks associated with web development that quickly become repetitive and mundane. Thankfully, we will no longer have to do these manually!

The tasks that we can now automate are (in no particular order):

• Sass (or Less) compilation (converting our Sass or Less to standard CSS)
• Concatenation (combining multiple files into one)
• Minification (smushing text together to reduce the size, making it load faster)
• Linting (automatically checking code for errors)
• Copying of files (like fonts)
• Adding vendor-specific prefixes to our CSS (ensuring compatibility across browsers)
• Detecting features that we require a user’s browser to have
• More that I can’t think of!

And best of all, the build system will be smart enough to understand when a particular file changes to prevent rebuilding the entire thing.

Stay tuned for the next article! For now, you can always take a look at DMC’s Web Application Development services, where we can harness the technologies outlined above for your needs.

The post Automating Web Development – Tools appeared first on DMC, Inc..

The post VR Labyrinth: Exploring the Tilt Table with an Oculus Rift appeared first on DMC, Inc..

Normally I would do this by simply throwing a Data Annotation Range Attribute on my model field and then using a ValidationMessageFor HTML Helper in my view and call it a day, but in this case that solution did not meet the client’s requirements. Using the simple approach above would not allow for configurable ranges since attribute properties have to be hard coded.

My next standard approach was to create a custom range checking attribute to use in my model. This attribute would include the logic for pulling the range limits from the database. However, this approach proved to be somewhat flawed since every time a field with this attribute was rendered in a view, an extra database query would be required, and that seemed somewhat excessive.

My first reaction whenever I notice excessive database queries is to see how I can use Output Caching. The ASP.NET MVC framework makes caching very easy to do: since the limit values would only be changing every few days, it seemed like a perfect opportunity to leverage Output Caching. So I ripped out all of the attributes that I had added to my model and came up with a solution that consists of the following pieces:

1) A controller action with caching enabled that retrieves the limits for a specific property. In this case I made a controller with a single action just for this purpose. The controller extends the BaseController class that gives it access to the database access function called GetRangeLimitsForField. The controller action GetFieldRangeLimits chaches its results for five minutes and varies by the field parameter. If you don’t set the VaryByParam properly, then the action will end up caching a value for one field and returning that value for all fields. I also created a DataFields enum that is essentially a list of all fields that I would ever need to set validation limits on, and I created a RangeLimitViewModel as well (which is included below the controller code).

public class RangeLimitController : BaseController
{
    [OutputCache(Duration = 300, VaryByParam = "field")]
    public ActionResult GetFieldRangeLimits(DataFields field)
    {
        var rangeLimitViewModel = new RangeLimitViewModel()
        {
            Field = field
        };

        var rangeLimits = this.GetRangeLimitsForField(field);

        if (rangeLimits != null)
        {
            rangeLimitViewModel.LowerLimit = rangeLimits.LowerLimit;
            rangeLimitViewModel.UpperLimit = rangeLimits.UpperLimit;
        }

        return PartialView("_RangeLimit", rangeLimitViewModel);
    }
}

public class RangeLimitController : BaseController
{
    [OutputCache(Duration = 300, VaryByParam = "field")]
    public ActionResult GetFieldRangeLimits(DataFields field)
    {
        var rangeLimitViewModel = new RangeLimitViewModel()
        {
            Field = field
        };

        var rangeLimits = this.GetRangeLimitsForField(field);

        if (rangeLimits != null)
        {
            rangeLimitViewModel.LowerLimit = rangeLimits.LowerLimit;
            rangeLimitViewModel.UpperLimit = rangeLimits.UpperLimit;
        }

        return PartialView("_RangeLimit", rangeLimitViewModel);
    }
}

2) A partial view that generates some client-side attributes that store the limits for a field. This partial view uses the RangeLimitViewModel that is created in the GetFieldRangeLimits action.

@model RangeLimitViewModel

data-limit-field="@Model.Field"

@if (Model.LowerLimit.HasValue)
{
    <text>data-limit-lower="@Model.LowerLimit.Value"</text>
}

@if (Model.UpperLimit.HasValue)
{
    <text>data-limit-upper="@Model.UpperLimit.Value"</text>
}

@model RangeLimitViewModel

data-limit-field="@Model.Field"

@if (Model.LowerLimit.HasValue)
{
    <text>data-limit-lower="@Model.LowerLimit.Value"</text>
}

@if (Model.UpperLimit.HasValue)
{
    <text>data-limit-upper="@Model.UpperLimit.Value"</text>
}

3) A few simple JQuery functions that target any text boxes contained within divs that have the range limit attributes and that highlight the text boxes if their value goes out of the specified range.

function checkIfInputIsInRange(inputBox, fieldName, lowerLimit, upperLimit) {
    var currentValue = $(inputBox).val();
    var numberValue = parseFloat(currentValue);

    if (currentValue === "" || isNaN(numberValue)) {
        $(inputBox).removeClass("out-of-range");
        return;
    }

    if ((!isNaN(lowerLimit) && numberValue < lowerLimit) ||
        (!isNaN(upperLimit) && numberValue > upperLimit)) {
        $(inputBox).addClass("out-of-range");
    } else {
        $(inputBox).removeClass("out-of-range");
    }
}

function checkIfInputIsInRange(inputBox, fieldName, lowerLimit, upperLimit) {
    var currentValue = $(inputBox).val();
    var numberValue = parseFloat(currentValue);

    if (currentValue === "" || isNaN(numberValue)) {
        $(inputBox).removeClass("out-of-range");
        return;
    }

    if ((!isNaN(lowerLimit) && numberValue < lowerLimit) ||
        (!isNaN(upperLimit) && numberValue > upperLimit)) {
        $(inputBox).addClass("out-of-range");
    } else {
        $(inputBox).removeClass("out-of-range");
    }
}

4) And a CSS class to highlight a text box with a red border.

.out-of-range,
.out-of-range:hover {
    border-color: red;
}

.out-of-range,
.out-of-range:hover {
    border-color: red;
}

And now you could use the functionality like this in a view:

<div @{ Html.RenderAction("GetFieldRangeLimits", "RangeLimit",
        new { field = DataFields.ExampleField }); }>
    @Html.EditorFor(model => model.ExampleField)
</div>

<script type="text/javascript">
    configureLimitInputs();
</script>

<div @{ Html.RenderAction("GetFieldRangeLimits", "RangeLimit",
        new { field = DataFields.ExampleField }); }>
    @Html.EditorFor(model => model.ExampleField)
</div>

<script type="text/javascript">
    configureLimitInputs();
</script>

The post Dynamic Database-Driven Validation Ranges in ASP.NET MVC appeared first on DMC, Inc..

The end goal of the DMC Highlight Cam project is three-fold:

1. Have a camera mounted so that it can continually record all activity at the ping pong table (or any other place where interesting things *might* happen)
2. Have the ability to press a single button when something AWESOME/EXCITING/FUNNY/MEMORABLE happens to capture and archive footage of that awesome event
3. When a “highlight” is identified by the user, automatically transfer the video files for the last X seconds (say 60 seconds, adjustable) off the camera and archive it in some centrally accessible location so that it may be watched as a “replay” (slow mo, etc.), posted on the website, or compiled into a highlight reel (“Best of DMC Ping Pong 2014”)

Fed Ex Day Accomplishments Included:

• Selecting GoPro Hero 3+ Black Edition as camera
  • Reason 1: About as high of resolution and high frame rate recording as you can get for the $
  • Reason 2: Supports a Wi-Fi interface that allows control of camera and access to data remotely over Wi-Fi
• Figuring out how to use natively supported automatic “looping” recording mode that breaks video into one minute segments, and only keeps the most recent five segments (exactly what we needed for this application to prevent memory card from filling up)
• Implementing a .NET application that leverages the available Wifi interface to do the following:
  • Power up GoPro Camera
  • Apply desired video resolution, frame rate, looping mode configuration settings to camera
  • Start video recording
  • Wait for a user to press a key to identify an AWESOME highlight event
  • When highlight event is identified
    • Gather a listing of the available video files on the GoPro and identify the two most recent video segments
    • Transfer those video files from the HTTP file server hosted by the GoPro to a local disk (archive) location
    • Continue recording and wait for user to identify the next highlight event
• Implementing an Android App with similar (slightly limited) functions to interface/communicate with the GoPro

Our team created a successful proof of concept for all required GoPro camera integration functions. We made a clear path toward a refined version that will be hosted somewhere on the DMC network and can be controlled through the existing DMC ping pong app.

The post DMC Highlight Cam Project appeared first on DMC, Inc..

A client had an existing database we needed to interact with using an ORM; this necessitated a database-first approach. Furthermore, this database’s schema was mirrored in other databases with slight modifications. DMC had to build an application that could talk to all of these databases – which were 99% similar – using a single interface, so that new, slightly different schemas could be dropped in without a problem.

The problem with a database-first ORM, here Microsoft Entity Framework 5, was that the use of multiple database objects infected the business logic. The schemas were similar enough that a single interface could be abstracted out. The only question after devising this interface was how to implement it using the Entity Framework generated files.

Consider a table called Entity, with a field called Property. This schema exists on different database servers with different query strings, and Property is slightly different between the two. For simplicity’s sake lets say it’s a number in one database and a numeric string in another database.

Interacting with Property with the Entity Framework would require two database models and their associated classes, with one Property class being a float and another Property class being a string. Our interface presents this as a float.

public interface IEntity
{
  float Property { get; set; }
}

public interface IEntity
{
  float Property { get; set; }
}

To interact with both, we create explicit implementations of the interface for the Entity table on a partial class mapped to the Entity class generated by our database-first approach. One implementation of this interface is a pass-through to the first Property member of the generated partial class. The other converts the float to a string before passing the converted value on to the second generated Property member.

Now that we have abstracted the Entity table, let’s abstract the database itself. In Entity Framework, tables are represented as DbSets. DbSet implements IQueryable, which is sufficient for querying the database using Linq. The interface follows.

public interface IDatabase : IDisposable
{
  IQueryable<IEntity> Entity { get; }

  IEntity CreateEntity();
  IEntity Add(IEntity entity);

  int SaveChanges();
}

public interface IDatabase : IDisposable
{
  IQueryable<IEntity> Entity { get; }

  IEntity CreateEntity();
  IEntity Add(IEntity entity);

  int SaveChanges();
}

Note that additional Create and Add methods are required since IQueryable does not support these operations.

Implementing this interface is as simple as implementing IEntity. Explicitly implement IDatabase on a partial class of Database and pass the required properties from the Entity Framework-generated class to the interface implementation.

That’s it. Note that when implementing an ICollection foreign key property on a table, you will need to cast it as IEnumerable in the interface. This cast is handled implicitly with .NET 4.5.

There’s one more trick, though. The Entity Framework is not smart enough to take namespace into account when mapping code objects to database objects. So if you are implementing IEntity multiple times, each implementation will have to be done within its own assembly and namespace. A good solution architecture is to have an interface project referenced by each implementation project and then finally a factory project that references the interface project and all implementation projects. The factory methods can give you a different implementation of IDatabase based upon some parameter.

Learn more about DMC’s custom hardware and software development services.

The post Abstracting an ORM to Use Multiple Backends appeared first on DMC, Inc..