Is there a faster way?

Assuming your Regions don't overlap, span a continuous range, and you don't have any weird gaps. I'd just sort the Regions in ascending order and then in reverse order find the first region that is less than the three upper bounds. It'll save you half the checks. It's a simple change.

Like SAKryukov said, you can change the data structure and see some performance improvements. It just means taking advantage of your data's characteristics in some way.

It really just makes me wonder that you're trying to optimize something so simple. To me this means one of three things:

1) You really call this way too much, which to me I'd see if there is a way to cache these results so you don't have to if that makes sense.

2) You are really desperate for milliseconds of time. You really can't do much about that but keep pushing the envelope further.

3) You are looking at the wrong thing. If you've determined that this is indeed your bottleneck, see item 1. If you haven't and you just believe this is your bottle neck, I'd focus elsewhere first.

I just can't resist joining the play on this one :)

using System.Collections.Generic;

namespace TestVNCRegions
{
    public class VNCRegion
    {
        public string VNCRegionName;
        int LoVelocity;
        int HiVelocity;
        int LoNote;
        int HiNote;
        int LoChannel;
        int HiChannel;

        public static List<VNCRegion> VNCRegions = new List<VNCRegion>();

        public static VNCRegion NewVNCRegion;

        public static void AddVNCRegion(string vncRegionName, int lVel, int hVel, int lNte, int hNte, int lChn, int hChn)
        {
            NewVNCRegion = new VNCRegion
            {
                // by adjusting the values here
                // we can save comparison time ?
                VNCRegionName = vncRegionName,
                LoVelocity = lVel + 1,
                HiVelocity = hVel - 1,
                LoNote = lNte + 1,
                HiNote = hNte - 1,
                LoChannel = lChn + 1,
                HiChannel = hChn - 1
            };

            VNCRegions.Add(NewVNCRegion);
        }

        public static VNCRegion FindRegion(int velocity, int note, int channel)
        {
            foreach (VNCRegion theRegion in VNCRegions)
            {
                if
                (
                    velocity > theRegion.LoVelocity
                    && velocity < theRegion.HiVelocity
                    && note > theRegion.LoNote
                    && note < theRegion.HiNote
                    && channel > theRegion.LoChannel
                    && channel < theRegion.HiChannel
               )
               return theRegion;
            }

            return null;
        }
    }
}

And a test might look like this:

VNCRegion.AddVNCRegion("region1", 1, 20, 4, 43, 2, 99);
VNCRegion.AddVNCRegion("region2", 21, 32, 45, 66, 100, 145);
VNCRegion.AddVNCRegion("region3", 33, 55, 67, 89, 146, 200);

VNCRegion foundRegion1 = VNCRegion.FindRegion(18, 12, 34);
if (foundRegion1 != null) Console.WriteLine("test 1 returns: " + foundRegion1.VNCRegionName);

VNCRegion foundRegion2 = VNCRegion.FindRegion(24, 50, 102);
if (foundRegion2 != null) Console.WriteLine("test 2 returns: " + foundRegion2.VNCRegionName);

VNCRegion foundRegion3 = VNCRegion.FindRegion(44, 72, 198);
if (foundRegion3 != null) Console.WriteLine("test 3 returns: " + foundRegion3.VNCRegionName);

Discussion: I find this a very interesting question because I can 'envision' a wide gamut of problems in which similar discrimination of items which must match multiple range criteria is required.

While this may be simply 'fantasy,' I wonder if there might be a way to calculate a unique hash ... based on range values, for some sub-set of this type of problem ... that might result in a highly optimized search. Trying to conceptualize higher-order solutions to this type of problem, alas, I encounter my lack of formal computer science education. But, that limit just makes me more insatiably hungry for knowledge :)

And, a final aside: sometimes I think there's a curious lack of an object (an object encapsulating a struct ?) in .NET named 'Range.' That you might use like this:

Range<int> myIntRange = new Range<int> { 12, 24 };

if(myIntRange.Contains(22)) ...

Range<char> myCharRange = new Range<char> { 'k', 'r' };

if (! myCharRange.Contains('x')) ...</char></char></int></int>

If I understand your problem correctly, velocity, note, and channel form a 3-dimensional coordinate system. You have a large number of axis-aligned rectangular boxes and want to quickly find the one containing a given point.

A general solution would be to use an Interval Tree[^].

But a lot of the complexity in the interval tree comes from the support for overlapping regions. Given that your find method returns only a single region, I assume that regions are non-overlapping in your case.
Then, it would suggest storing your regions in a spacial data structure (e.g. a K-d tree[^]).
You'll have to re-build the whole data structure whenever the list of regions changes, though; so this is only helpful if you do lots of queries on the same set of regions.

The basic idea could be that each node in the tree represents an rectangular box of space. The root node represents the whole space (int.MinValue to int.MaxValue). Leaf nodes associate that space with one of your region objects (or no region, if that space is empty); while non-leaf nodes partition the space (see K-d tree for details).
Searching for a point in this tree is simple and works in time proportional to the height of the tree. The tricky part is constructing the space partition so that the tree is well balanced.
If the tree is well balanced, lookups will take O(lg N) time.

The first thing I thought of was changing the isWithinRegion function so that not all checks need to be performed.

//somewhere in the Region class
public bool isWithinRegion(int channel, int note, int velocity)
{
    bool result = true;

    if (channel < this.LoChannel || channel > this.HiChannel)
        result = false;
    else
    if (note < this.LoNote || note > this.HiNote)
        result = false;
    else
    if (velocity < this.LoVelocity || velocity > this.HiVelocity)
        result = false;

    return result;
}

See if this gives you better performance.