range Archive - Robert Skibbe

C# Bluetooth example – searching & listing devices in 2024

Robert Skibbe — Tue, 12 Jul 2022 23:22:59 +0000

C# Bluetooth Example – Listing devices

A simple C# Bluetooth example

A simple and easy to use C# bluetooth example, this was the thing I was looking for in the last days. I needed it for my remake of my logistics software called „Motraso“, but let’s talk about that in a second. We will talk about the basic functionality considering the creation of a simple „BluetoothClient“ instance, which is able to list devices and more. I will also add some more functionality in a later post, or edit this one – stay tuned!

Maybe you want to take a look at my blog post considering an actual bluetooth call on your phone as well?

Prefering videos? Gotcha back!

In case you don’t want to read the text, here is an example with a Windows Forms Bluetooth application as video format. Keep in mind, that the blog post contains more details like with WPF, etc. – which is not covered in the video.

My app needed a bluetooth upgrade

So in my current remake of my logistics software „Motraso“, I wanted the user to be able to make a direct call through their app. Speaking about „direct“, I’m meaning the actual dial process without further interaction from the user – yay! So far, the webapp-version did something similar by just providing some hyperlinks with the corresponding a-tags.

This kind of behaviour is implemented in like every webbrowser-capable device by providing for example an email link:

The text you want the user to see..

Which would look like this here (no click intended..):

The text you want the user to see..

Basically, this is pretty neat, as it’s supported in almost every modern device, but usually there will be some kind of confirmation. This also counts for the desired phone dial approach, which essentially works in the same manner:

Maybe display the phone number, or an icon..

Preview:

Maybe display the phone number, or an icon..

This is not what I wanted – meh.. I wanted to provide some nice functionality to my users, where they can only click a button and voila – the device (like a phone, etc.) will just call that number. No need for user interaction, no special permissions, nothing! This is where I came up with another idea, using bluetooth!

I mean seriously, who wants to pull out his phone out of his pocket, just to say: „Yes, I REALLY want to call this guy using bluetooth“. So I’m pretty glad I stumbled upon the following library.

Library search and installation – C# Bluetooth example

C# Bluetooth example – much work, little time

So as always – time’s short, work being much – I thought about browsing some of the known sources for developers. For sure I did hit Stackoverflow (who would’ve thought of that..) and – as a .NET Dev – I did take a look into the NuGet packages. Pretty fast, I’ve found a big and nice library which I can actually remember working with in the past.

At that time I was working on a project for one of my former employers, which needed to connect to a machine measuring the kick-speed of a football player for a sports event. Yeah, yeah, I hear you – that’s another story, so back to topic. The library I’m talking about is called „InTheHand.32feet„.

My best bet was, to just install that library and try out some things and it worked so far. Later, when I actually went to dialing, etc. this was a bit more of a headache, but this will be content for another post (or an edit/update). So for now, you can go ahead and actually install the mentioned library by using the following steps.

Creating a new project, installing the 32feet lib

Open a new Visual Studio project (or use your existing one…) and make a right click on your project name on the right side, it should be listed inside the project folder explorer. Take care to actually hit the project itself, not the overview thingy. Please don’t get confused, as this is a german-named test-project for one of my customers. Just click the item with that little green C# icon in front of its text contents.

C# Bluetooth Example – Right clicking the project name inside the project folder explorer

Now this context menu will appear, where you can click on the „Manage NuGet packages“-item (sorry, german as well..):

Manage NuGet packages for project

Installing 32feet Library

To finish up installing the needed library, just go ahead and search for „32feet“ in the box „1“. Then choose the correct package marked with „2“ and finally click „install“ on the right side, which should be number „3“. After the installation process has finished without any errors, you should be able to use the corresponding classes, functions and etc.

If the NuGet paket manager doesn’t display the check mark thingy right away, just refresh or close and open it up again. This is some kind of pretty well known bug inside the package list, so no need to panic.

Searching for bluetooth devices

In the last/main step, we are going to actually search for devices. To be able to do so, you need to create an instance of the „BluetoothClient“-class, which is inside the „InTheHand.Net.Sockets“-namespace. Keep in mind, that I’m using the shortcut / inference styled initialization syntax for the variables. You can do it like this:

Instantiating the BluetoothClient

var bluetoothClient = new BluetoothClient();

Dim bluetoothClient = new BluetoothClient()

If you prefer that explicit writing style (which I only do, when the concrete type isn’t obvious enough – but that’s like personal preference), just take a look at the next example. I just like that „keep it smart and simple“ thing, you know!?

BluetoothClient bluetoothClient = new BluetoothClient();

Dim bluetoothClient As BluetoothClient = new BluetoothClient()

Searching for devices

To start the actual search for bluetooth devices, you need to call the „DiscoverDevices“ function, of the „BluetoothClient“-instance. This will return an Array of the „BluetoothDeviceInfo“-class. Keep in mind, that this can be some kind of laggy, but we will fix this as well, soon:

var bluetoothDevices = bluetoothClient.DiscoverDevices();

Dim bluetoothDevices = bluetoothClient.DiscoverDevices()

To make it less laggy, we can actually delegate it to the „Task.Run“ helper function and use the return value of that – making it async. Keep in mind to use it in an async context, meaning like an async marked Task itself.

public async Task SearchDevicesAsync()
{
  var bluetoothClient = new BluetoothClient();
  var bluetoothDevices = await Task.Run(() => bluetoothClient.DiscoverDevices());
  bluetoothClient.Close();
  return bluetoothDevices;
}

Public Function SearchDevicesAsync() As BlutoothDeviceInfo()
  Dim bluetoothClient = New BluetoothClient()
  Dim bluetoothDevices = Await Task.Run(Function() bluetoothClient.DiscoverDevices())
  bluetoothClient.Close()
  Return bluetoothDevices
End Function

Maybe you could improve further by making use of the using statement, instead of closing the bluetooth client manually. Currently I’m elaborating on the reuse of the Bluetooth client, so maybe you can update me here as well, if you’ve found out interesting stuff!

Implementation inside a C# Winforms App

Windows Forms C# Bluetooth Example Application

As always, I’d like to provide a nice, working and „ready to use“ example, you are welcome to download it further below. At first we will take a look at a Windows Forms application (with C#, but I mean you can easily translate the code with the above help..).

So go ahead and create a new Windows Forms App, use the NET Version 6 and install the library as explained above. If you’ve finished those steps, we can go further on creating the Windows Forms App / UI. As I personally pretty much hate laggy sh** I will of course use an asynchronous approach.

The UI

Inside this Windows Forms App considering a C# Bluetooth example, I will use two basic list variations, searching and listing our bluetooth results. One will be more or less self-implemented, the other one is a basic „ListBox“-control. Add a „FlowLayoutPanel“ with a size of like 289 x 241 and a „ListBox“ with a size of 179 x 244 to your form. Next take a button and name those controls in a nice manner as you always should.

The Code

Now we are going to add some code to our Winforms C# Bluetooth example application. At first we will create some temporary data stores for our values / class instances. Notice, that I’m using the newer filescope namespace syntax, as I love saving unnecessary spaces.

using BluetoothExampleWinformsDeviceSearchCS.Controls;
using InTheHand.Net.Sockets;

namespace BluetoothExampleWinformsDeviceSearchCS;

public partial class Form1 : Form
{

    List _bluetoothDevices;

    bool _isSearchingForDevices;

    public bool IsSearchingForDevices
    {
        get => _isSearchingForDevices;
        set
        {
            _isSearchingForDevices = value;
            btnScanForDevices.Enabled = !_isSearchingForDevices;
        }
    }

    // more to come..

}

Create a constructor for the form in the next step, this will initialize the device data store and configure the „ListBox“.

    public Form1()
    {
        InitializeComponent();
        _bluetoothDevices = new List();
        lbBluetoothDevices.DisplayMember = "DeviceName";
    }

Next, go inside the click handler of the button (with double clicking it inside the designer, or using another method) and use the following code. Keep in mind, that we are using the code already provided above, as well. At first we will set our busy flag, to indicate – well – that we are busy. Then we are clearing potential leftovers from a previous run.

After that, we are fetching our bluetooth devices and add them to our backing store all at once. If it fails for whatever reason, we will output a message containing the details. At last, we will render our UI and set the searching flag to false.

    private async void btnScanForDevices_Click(object sender, EventArgs e)
    {
        IsSearchingForDevices = true;
        _bluetoothDevices.Clear();
        flpBluetoothDevices.Controls.Clear();
        lbBluetoothDevices.Items.Clear();
        try
        {
            var bluetoothDevices = await SearchDevicesAsync();
            _bluetoothDevices.AddRange(bluetoothDevices);
        }
        catch (Exception ex)
        {
            MessageBox.Show($"Couldn't search for bluetooth devices: {ex.Message}");
        }
        if (_bluetoothDevices.Count > 0)
        {
            DisplayFlpItems();
            DisplayLbItems();
        }
        IsSearchingForDevices = false;
    }

Both methods caring about the UI lists look like this. I also added the little handler function which gets connected dynamically. Don’t forget to kill those handler when closing the form, I’m doing this in the last method.

    private void DisplayFlpItems()
    {
        foreach (var device in _bluetoothDevices)
        {
            var bluetoothDeviceItem = new BluetoothDeviceItem(device);
            bluetoothDeviceItem.Click += BluetoothDeviceItem_Click;
            flpBluetoothDevices.Controls.Add(bluetoothDeviceItem);
        }
    }

    private void BluetoothDeviceItem_Click(object? sender, EventArgs e)
    {
        var deviceItem = sender as BluetoothDeviceItem;
        var device = deviceItem!.Device;
        MessageBox.Show($"You clicked on device: {device!.DeviceName}");
    }

    private void DisplayLbItems()
    {
        lbBluetoothDevices.DataSource = null;
        lbBluetoothDevices.DataSource = _bluetoothDevices;
    }

    private void Form1_FormClosing(object sender, FormClosingEventArgs e)
    {
        if (flpBluetoothDevices.Controls.Count > 0)
        {
            foreach (var bluetoothDeviceItem in flpBluetoothDevices.Controls.OfType())
            {
                bluetoothDeviceItem.Click -= BluetoothDeviceItem_Click;
            }
        }
    }

Last step – our little custom UserControl

To improve the visualization of the items a bit (well, in terms of Winforms..), I created a small „UserControl“ holding some information. It will contain the name and the bluetooth address of the corresponding device. You can create a new subfolder in your project called „Controls“ and add a new „UserControl“ there. I will call it „BluetoothDeviceItem“.

Add two labels, style them in your favour and don’t forget to change the „AutoSize“ property to „false“, with an explicit width. You can avoid overflowing the control this way. The control could look like this for example:

Bluetooth Windows Forms App UserControl

Implementation inside a C# WPF MVVM App

WPF MVVM Bluetooth Example App

Next we will take a look on how this could look inside a more modern WPF MVVM App. Even though MVVM being a personal preference, you should be able to easily switch out necessary components. Another thing would be, that I will actually use some of my favourite WPF Tools for the app, so skip what you don’t want / need out of those 🤷‍♂️.

For sure, we will also use the async approach here as well, cause we don’t want laggs here as well. But first, start a new project over here as well. Pick the WPF App Visual Studio template and choose NET 6 as well. Now we will do the basic MVVM setup stuff, where I won’t go into too much detail – I will cover this in detail in a future post.

The WPF UI

Go ahead and install my favourite WPF NuGet helper libraries:

Autofac – Managing dependency injections, IoC, etc.
Caliburn.Micro – Easier WPF work by naming conventions
MahApps.Metro – One of my favourite Design Toolkits
PropertyChanged.Fody – Get rid of annoying NotifyPropertyChanged implementations

After you’ve installed the recommended libraries (or prefer to go without them), continue with installing the most important package. I’m talking about the used bluetooth lib from above.

Then create the basic MVVM folders (if used) inside your project folder like this:

Converters
ViewModels
Views

Necessary imports inside App.xaml

After that we can continue by importing the necessary styles and other things inside the „App.xaml“ file. As we are not using the default boot-process in my case, take care of that removed Start-Uri thingy from at the top.

Bootstrapping the App

Next we will create 2 classes being able to actually bootstrap our app. The first one is the base, which provides essential base functionality. Don’t worry if you don’t understand everything there, just read it carefully and learn step by step – for this example just take this note: It’s a generic bootstrapping base for our app.

using System.Linq;
using Autofac;
using Caliburn.Micro;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Windows;
using IContainer = Autofac.IContainer;
using BluetoothExampleWpfDeviceSearch.ViewModels;

namespace BluetoothExampleWpfDeviceSearch;

public abstract class TypedAutofacBootstrapper : BootstrapperBase
{
    public static IContainer? Container { get; private set; }

    protected IEventAggregator? _eventAggregator { get; private set; }

    public TypedAutofacBootstrapper()
    {
        Initialize();
    }

    #region Overrides
    protected override void Configure()
    {
        var builder = new ContainerBuilder();

        RegisterBasicUtilities(builder);
        RegisterViewModels(builder);
        RegisterViews(builder);

        ConfigureContainer(builder);

        Container = builder.Build();
    }

    protected void RegisterBasicUtilities(ContainerBuilder builder)
    {
        builder.RegisterType()
            .As()
            .SingleInstance();

        _eventAggregator = new EventAggregator();
        builder.RegisterInstance(_eventAggregator)
            .As()
            .SingleInstance();
    }

    protected static Func mustEndWithViewModelButNotShellViewModel = type => type.Name.EndsWith("ViewModel") && type.Name != "ShellViewModel";
    protected static Func mustBeInNamespaceEndingOnViewModels = type => !string.IsNullOrWhiteSpace(type.Namespace) && type.Namespace.EndsWith("ViewModels");
    protected static Func mustImplementPropertyChanged = type => type.GetInterface(nameof(INotifyPropertyChanged)) != null;

    protected void RegisterViewModels(ContainerBuilder builder)
    {
        var assembly = AssemblySource.Instance;
        builder.RegisterAssemblyTypes(assembly.ToArray())
          .Where(type => type.Name == nameof(ShellViewModel))
          .AsSelf()
          .SingleInstance();
        //.PropertiesAutowired();
        builder.RegisterAssemblyTypes(assembly.ToArray())
          .Where(mustEndWithViewModelButNotShellViewModel)
          .Where(mustBeInNamespaceEndingOnViewModels)
          .Where(mustImplementPropertyChanged)
          .AsSelf()
          .InstancePerDependency();
        //.PropertiesAutowired();
    }

    protected static Func mustEndWithView = type => type.Name.EndsWith("View");
    protected static Func mustBeInNamespaceEndingOnViews = type => !string.IsNullOrWhiteSpace(type.Namespace) && type.Namespace.EndsWith("Views");

    protected void RegisterViews(ContainerBuilder builder)
    {
        var assembly = AssemblySource.Instance;
        builder.RegisterAssemblyTypes(assembly.ToArray())
          .Where(mustEndWithView)
          .Where(mustBeInNamespaceEndingOnViews)
          .AsSelf()
          .InstancePerDependency()
          .PropertiesAutowired();
    }

    protected override object GetInstance(Type serviceType, string key)
    {
        if (string.IsNullOrWhiteSpace(key))
        {
            if (Container.IsRegistered(serviceType))
                return Container.Resolve(serviceType);
        }
        else
        {
            if (Container.IsRegisteredWithKey(key, serviceType))
                return Container.ResolveKeyed(key, serviceType);
        }
        throw new Exception($"Could not locate any instances of contract {key ?? serviceType.Name}.");
    }

    protected override IEnumerable GetAllInstances(Type serviceType)
    {
        var ienumerableType = typeof(IEnumerable<>);
        var genericServiceEnumerableType = ienumerableType.MakeGenericType(serviceType);
        return Container.Resolve(genericServiceEnumerableType) as IEnumerable;
    }

    protected override void BuildUp(object instance)
    {
        // Debug.WriteLine("BuildUp");
        Container.InjectProperties(instance);
    }
    #endregion

    protected override async void OnStartup(object sender, StartupEventArgs e)
    {
        base.OnStartup(sender, e);
        await DisplayRootViewForAsync();
        ApplicationStarted();
    }

    protected abstract void ApplicationStarted();

    protected abstract void ConfigureContainer(ContainerBuilder builder);
}

Now we will create the actual implementation of the previous class – our app specific bootstrapper. The you will see, that this class it’s much less code. It will just start the App window (which comes next) and provides the (base) „ShellViewModel“ instance.

using Autofac;
using Caliburn.Micro;
using BluetoothExampleWpfDeviceSearch.ViewModels;
using System.Linq;
using IContainer = Autofac.IContainer;

namespace BluetoothExampleWpfDeviceSearch;

public class Bootstrapper : TypedAutofacBootstrapper
{

    protected override void ConfigureContainer(ContainerBuilder builder)
    {
        // register more stuff specific to your app
    }

    protected override void ApplicationStarted()
    {

    }

}

Creating the ShellViewModel

The „ShellViewModel“ is the basic shell around our app, you could say, it’s the „window“. Go ahead and create it inside the „ViewModels“ folder. In modern applications, there are likely less windows being used. You basically switch out sub-views of the main app and only use windows if appropriate. So right now we’re only saying: When the app is started, show our start screen, which is basically a „CallViewModel“. Sorry for the name, took it out of the old project.

using Autofac;
using Caliburn.Micro;

namespace BluetoothExampleWpfDeviceSearch.ViewModels;

public class ShellViewModel : Conductor.Collection.OneActive
{

    public ShellViewModel()
    {
        ShowStartScreen();
    }

    private async void ShowStartScreen()
    {
        var callViewModel = Bootstrapper.Container.Resolve();
        await ActivateItemAsync(callViewModel);
    }
}

Now we need the corresponding view as well, the „ShellView“, which should be created inside the „Views“ folder (you may delete the MainWindow file previously!). I won’t go into Caliburn Micro, etc. here, because the post maybe is long enough right now haha. Basically we’re showing the current view (which is called ActiveItem) by naming convention based databinding.

The list page ViewModel

In this step, we will create the actual view for listing our devices. Create a new viewmodel called „CallViewModel“ (or correct it and directly name it BluetoothDeviceListViewModel).

We basically have a storage list, where we keep our found devices – notice the „BindableCollection“ type. This type comes from „Caliburn.Micro“ and helps us – seeing the name – with binding to a collection. Maybe a separate post will be coming for this, too, for now it’s enough to know.

Then we are keeping track of which device is actually selected with the „SelectedDevice“ property. And we are also remembering, if we are currently busy searching for devices. This will ensure, that the button isn’t usable, if we are already searching.

using Caliburn.Micro;
using InTheHand.Net.Bluetooth;
using InTheHand.Net.Sockets;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace BluetoothExampleWpfDeviceSearch.ViewModels;

public class CallViewModel : Screen
{

    public BindableCollection Devices { get; set; }

    public DeviceItemViewModel? SelectedDevice { get; set; }

    public bool IsSearchingDevices { get; set; }

    public CallViewModel()
    {
        Devices = new();
        IsSearchingDevices = false;
    }

    public async Task SearchDevices()
    {
        IsSearchingDevices = true;
        Devices.Clear();
        var client = new BluetoothClient();
        var devices = new List();
        try
        {
            devices.AddRange((await Task.Run(() => client.DiscoverDevices())).ToList());
        }
        catch (Exception ex)
        {
            Debug.WriteLine(ex.Message);
        }
        finally
        {
            Devices.AddRange(devices.Select(x => new DeviceItemViewModel(x)));
            client.Close();
            IsSearchingDevices = false;
        }
    }

    public bool CanSearchDevices => !IsSearchingDevices;

}

The list page View

Now add another UserControl inside the Views folder and call it „CallView“ (or use the corrected version like BluetoothDeviceListView). Here we are also using some of caliburns helper conventions. I’m just telling the „ListBox“: „Hey, your name is ‚Devices‘, so, bind to those“ – and it just works.

Then i’m defining a template for the items to be displayed. This could also be a separate file and the line I’ve commented out. Like this, caliburn would automatically look for a file fitting the naming style „DeviceItemViewModel“ -> „DeviceItemView“ whose ViewModel we are going to create now.

The device item ViewModel – the last step

In the last step, we will create a simple ViewModel to hold the device for us:

using Caliburn.Micro;
using InTheHand.Net.Sockets;

namespace BluetoothExampleWpfDeviceSearch.ViewModels;

public class DeviceItemViewModel : PropertyChangedBase
{

    public BluetoothDeviceInfo Device { get; }

    public DeviceItemViewModel(BluetoothDeviceInfo device)
    {
        Device = device;
    }

}

Conclusion – C# Bluetooth example

So in todays post we learned how to use the 32feet bluetooth library, to list / search for bluetooth devices. We covered a complete Windows Forms example and also a WPF MVVM app example of implementing the explained functionality. I hope this will get your bluetooth aware app on fire – cheers!

Downloads

Winforms-Example

WPF-Example

Der Beitrag C# Bluetooth example – searching & listing devices in 2024 erschien zuerst auf Robert Skibbe.

Excel Kalenderwoche

Robert Skibbe — Thu, 12 Aug 2021 19:01:11 +0000

Excel Kalenderwoche

Du möchtest eine Excel Kalenderwoche bestimmen, um zum Beispiel diverse Projekte wie einen Kalender, o. Ä. umzusetzen?

Dann begrüße ich Dich herzlich in meinem heutigen Beitrag über die Kalenderwoche, bzw. die Kalenderwochen-Funktion in Excel!

Vielleicht helfen Dir später auch noch weitere Beiträge zum Thema Microsoft Excel, wie Diese hier: VBA Makro, Range, IFS VBA.

Kalenderwochen – Häufig gebraucht

Ich denke absolut jeder, der mal mit Daten (plural Datum) gearbeitet hat, ist früher oder später an ein und dasselbe Problem geraten – Kalenderwochen.

Diese Problemstellung ist wie viele Andere auch, nicht plattformabhängig, da z. B. Kalender nun einmal auf verschiedenen Plattformen gebraucht werden.

Was jedoch Plattform– und auch kontextual–abhängig ist, sind deren jeweilige Umsetzungen auf den entsprechenden Plattformen.

Google-Kalender – Ein Beispiel

Neben Microsoft Outlook verwenden natürlich auch andere bekannte Anbieter wie z. B. Google die Darstellung von Kalenderwochen.

Bei Outlook muss man Diese teilweise (also je nach Version und Einstellungen) allerdings erst aktivieren.

Auf dem Handy sehe ich aktuell auch in der Monatsansicht z. B. keine Kalenderwochen (ich nutze aktuell ein iPhone XR mit dem iOS-Kalender).

Kalenderwochen im Google Kalender

Excel Kalenderwoche, etwa berechnen?

Im Internet finden sich für die verschiedensten Sprachen und Plattformen Codeschnippsel, wie man die Kalenderwoche eines gegebenen Datum berechnen kann.

Wie man Kalenderwochen errechnet, bzw. bestimmt ist ja mehr oder weniger ein offenes Geheimnis, denn wie fast alles im Leben, gibt es auch hierfür Normen.

Unter anderem gibt es die für uns eher interessante Norm „ISO8601“ und die z. B. in den USA vertretene Norm.

Zum Glück gibt es aber zumindest einige Hilfsmittel, Welche es uns ermöglichen, auf vorhandene Tools zurückzugreifen, statt alles in Eigenarbeit zu berechnen.

Das sieht dann je nach Programmier– und Skriptsprache ggf. anders aus und ist mal mehr und mal weniger kompliziert.

Hier siehst Du beispielsweise ein ISO8601–Beispiel aus dem VB.NET-Umfeld:

Public Shared Function GetIso8601WeekOfYear(time As DateTime) As Integer
    Dim day As DayOfWeek = CultureInfo.InvariantCulture.Calendar.GetDayOfWeek(time)

    If day >= DayOfWeek.Monday AndAlso day <= DayOfWeek.Wednesday Then
        time = time.AddDays(3)
    End If

    Return CultureInfo.InvariantCulture.Calendar.GetWeekOfYear(time, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday)
End Function

Durch Verwendung von VBA-Code

Wer im Bereich Excel unterwegs ist, wird vermutlich auch irgendwann in Kontakt mit Microsofts Skriptsprache Visual Basic for Applications (kurz VBA) kommen.

Auch dort könnte eventuell die Notwendigkeit für die Erörterung der Kalenderwoche eines bestimmten Datums vorkommen.

In VBA selbst gibt es dazu eine relativ einfache Funktion, Welche sich in der Dokumentation unter dem Namen „WeekNum“ versteckt.

Ein möglicher Beispielcode dazu könnte so aussehen:

Dim weekNumber As Integer = WorksheetFunction.WeekNum(now, vbMonday)
' do something with weekNumber..

Gerade und ungerade Kalenderwochen

Eventuell besteht ja auch die Notwendigkeit zum Beispiel in „geraden Kalenderwochen“ anders zu verfahren, als in Ungeraden.

Womöglich möchte man die Reihen, oder Spalten anders färben, oder die Werte innerhalb der Zellen anders verarbeiten.

Dies könnte man z. B. wie folgt lösen:

Dim weekNumber As Integer = WorksheetFunction.WeekNum(now, vbMonday)
Dim isWeekNumberEven As Boolean = weekNumber Mod 2
If isWeekNumberEven Then
    ' do something on even weeknumber..
Else
    ' do something on odd weeknumber
End If

Excel Kalenderwoche – Einfachste Methode

Ganz nach dem „das Beste kommt zum Schluss„-Motto, gibt es in Excel wohl (zum Glück) eine sehr einfache Variante, um an die Kalenderwoche zu kommen.

Dazu verwendet man die gleichermaßen benannte Methode namens KALENDERWOCHE – einfach, oder!?

Dessen genauen Aufbau mit Parametern und Details, kannst Du Dir in der oben verlinkten Seite der Dokumentation anschauen.

Achte bei dem folgenden Code-Beispiel besonders auf den zweiten Parameter, Dieser gibt eine wichtige Information an.

Der zweite Parameter der Funktion bestimmt dabei, an welchem Wochentag die Woche(n) für die Berechnung starten soll.

Beim ersten Parameter hingegen handelt es sich um den jeweiligen Wert (also das Datum), Welcher verwendet werden soll.

Dabei handelt es sich im unteren Beispiel natürlich um den Wert in der Zelle „A2„.

=KALENDERWOCHE(A2;2)

Der Beitrag Excel Kalenderwoche erschien zuerst auf Robert Skibbe.

VBA Range

Robert Skibbe — Sun, 18 Jul 2021 18:34:35 +0000

VBA Range

Du möchtest mit der VBA Range und somit mit einen ganzen Bereich in Excel arbeiten?

Lerne in diesem Beitrag, wie Du mit der VBA Range Funktion ganze Bereiche erfassen und verarbeiten kannst.

Vielleicht interessieren Dich zu einem anderen Zeitpunkt noch folgende Beiträge: VBA InStr, Array, Array Length.

Was ist eine VBA Range

Eine Range in VBA, bzw. in Microsoft Excel, ist – übersetzt gesehen – eine Reichweite von mehreren Zellen einer Tabelle.

Wie Du Dir sicher vorstellen kannst, können wir so diverse Zeilen und Spalten abbilden und letztendlich durchlaufen.

Damit können wir unter anderem Summierungen, oder andere eigene Arbeitsschritte anwenden.

Die Qual der Wahl

Naja ganz so schlimm ist es nicht 😂, jedoch gibt es 2 tolle Auswahlmöglichkeiten für die Ranges.

Die erste Möglichkeit auf die VBA Ranges zuzugreifen ist es, den User ganz einfach wie bekannt seine eigene Auswahl treffen zu lassen und dann im Code auf die Auswahl zuzugreifen.

Bei der zweiten Möglichkeit handelt es sich mehr oder weniger um eine manuelle Methode, wo wir – wie aus Excel bekannt – die Ranges mit ich nenne es mal „Selektoren“ bestimmen.

Manuelle Auswahl des Nutzers – VBA Range

Stell Dir vor, der Nutzer deiner Anwendung markiert die Zellen z. B. wie folgt:

VBA Range Excel Beispiel Auswahl

Er hat also praktisch die „Koordinaten“ A1, A2 und A3 in dieser Tabelle, bzw. diesem Tabellenblatt markiert.

Anders formuliert, könnte man diese „Range“ auch in „Excel-Sprache“ ausdrücken, was dann als „A1:A3“ bezeichnet werden würde.

Diese Range können wir im Grunde genauso in unserem VBA Skript verwenden, um die z. B. die Daten aus den respektiven Zellen abzurufen.

Auswahl via Code – VBA Range

Doch bevor wir mit dem tatsächlichen Abrufen von Werten, bzw. Iterieren von Zellen beginnen, werfen wir nochmal einen Blick auf die Auswahl der Range via Code.

Wie oben schon angesprochen verwenden wir dafür einen Ausdruck, Welchen ich als Selektor bezeichne und übergeben Diesen der Range-Funktion aus Excel.

Dim area
area = Range("A1:A3")

Im Code deklarieren wir dazu erstmal eine Variable namens „area“ und weisen Ihr anschließend den Rückgabewert der Range–Funktion zu.

Danach haben wir endlich die Möglichkeit, die einzelnen Zellen, Welche hier durch die Range widergespiegelt werden zu durchlaufen.

Zellen der Range durchlaufen

Um durch die einzelnen Zellen der Range zu iterieren nutzen wir im folgenden Beispiel die „For Each„-Schleife:

For Each cell in area
    ' do something
Next

Nun können wir innerhalb der einzelnen Schleifen-Durchläufe auf die jeweilige Zelle zugreifen.

Wir haben dadurch die Möglichkeit einerseits die hinter den Zellen steckenden Werte abgreifen und setzen, sowie die Formeln der Zellen verändern.

Werte der Zellen abrufen und verändern

Hier zeige ich Dir, wie Du einzelne Werte aus den Zellen abrufen und setzen kannst:

Werte abrufen

For Each cell in area
    Dim value = cell.Value
    ' so something with the value
Next

Werte setzen

For Each cell in area
    cell.Value = "The new Value!"
Next

Mit Formeln arbeiten

Im nächsten Abschnitt kümmern wir uns um das Setzen und Abrufen der Formeln.

Formel setzen

Wir haben die Möglichkeit die Formeln einer Range direkt zu setzen:

Range("A1:A3").Formula = "=Rand()"

Oder wie im obigen Beispiel mit Hilfe einer Schleife:

For Each cell in area
    cell.Formula = "=Rand()"
Next

Der Beitrag VBA Range erschien zuerst auf Robert Skibbe.

range Archive - Robert Skibbe

C# Bluetooth example – searching & listing devices in 2024

A simple C# Bluetooth example

Prefering videos? Gotcha back!

My app needed a bluetooth upgrade

Library search and installation – C# Bluetooth example

Creating a new project, installing the 32feet lib

Searching for bluetooth devices

Instantiating the BluetoothClient

Searching for devices

Implementation inside a C# Winforms App

The UI

The Code

Last step – our little custom UserControl

Implementation inside a C# WPF MVVM App

The WPF UI

Necessary imports inside App.xaml

Bootstrapping the App

Creating the ShellViewModel

The list page ViewModel

The list page View

The device item ViewModel – the last step

Conclusion – C# Bluetooth example

Downloads

Related posts

Excel Kalenderwoche

Excel Kalenderwoche

Kalenderwochen – Häufig gebraucht

Google-Kalender – Ein Beispiel

Excel Kalenderwoche, etwa berechnen?

Durch Verwendung von VBA-Code

Gerade und ungerade Kalenderwochen

Excel Kalenderwoche – Einfachste Methode

VBA Range

VBA Range

Was ist eine VBA Range

Die Qual der Wahl

Manuelle Auswahl des Nutzers – VBA Range

Auswahl via Code – VBA Range

Zellen der Range durchlaufen

Werte der Zellen abrufen und verändern

Werte abrufen

Werte setzen

Mit Formeln arbeiten

Formel setzen