Перенести готовый код в паттерн MVVM

using MillimarN1700LibCSharp;
using System;
using System.Windows;
using System.ComponentModel;
using System.Runtime.InteropServices;
 
namespace DevTemplate
{
    /// <summary>
    /// Логика взаимодействия для MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        double GetMeasureResult;
 
        public N1700Lib.N1700MsgCallback MCallback;
        public N1700Lib.N1700DataCallback DCallback;
 
        bool DataCallbackRegistered = false;
 
        int iResult;
        uint NumModules;
        uint NumChannels;
 
        bool Measuring = false;
 
        int LastTick;
 
        static int MaxModuleCount = 2;
        static int MaxChannelCount = 3;
 
        string VersionDll;
        string ValsSec;
        string LedUsbStick;
        string LedSwitch;
        string StatusMeasure;
 
        N1700Lib.sN1700_Module[] aN1700_Module = new N1700Lib.sN1700_Module[MaxModuleCount];
        N1700Lib.sN1700_Channel[] aN1700_Channel = new N1700Lib.sN1700_Channel[MaxChannelCount];
 
        N1700Lib.N1700version ver = new N1700Lib.N1700version();
 
        public MainWindow()
        {
            InitializeComponent();
 
            iResult = N1700Lib.N1700InitializeLibrary(false, out NumModules, out NumChannels, 0);
 
            IntPtr ptr = Marshal.AllocHGlobal(Marshal.SizeOf(ver));
            int result = N1700Lib.N1700GetVersion(ptr);
            ver = (N1700Lib.N1700version)Marshal.PtrToStructure(ptr, typeof(N1700Lib.N1700version));
 
            VersionDll = (ver.N1700lib.major).ToString("D2") + "." + ver.N1700lib.minor.ToString("D2") + "-" + ver.N1700lib.micro.ToString("D2");
 
            MCallback = new N1700Lib.N1700MsgCallback(MsgCallback);
            N1700Lib.N1700RegisterMsgCallback(MCallback);
 
            GetModulesData();
            GetChannelsData();
        }
 
        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            StartStop();
        }
 
        private void Window_Closing(object sender, CancelEventArgs e)
        {
            StartStop();
            N1700Lib.N1700UnregisterDataCallback(DCallback);
            N1700Lib.N1700FreeLibrary();
        }
 
        unsafe public void MsgCallback(int msg, uint channel, int param)
        {
            switch (msg)
            {
                //----------------------------------------------------------------------------------------------------------------------------------
                case N1700Lib.WM_N1700_Tick:
                    if (LedUsbStick == "Gray") LedUsbStick = "Lime";
                    else LedUsbStick = "Gray";
                    break;
                //----------------------------------------------------------------------------------------------------------------------------------
                case N1700Lib.WM_N1700_ModuleCountChanged:
                    NumModules = (uint)param;
                    GetModulesData();
 
                    break;
 
                //----------------------------------------------------------------------------------------------------------------------------------
                case N1700Lib.WM_N1700_ChannelCountChanged:
                    NumChannels = (uint)param;
                    GetChannelsData();
 
                    break;
                case N1700Lib.WM_N1700_MwProSek:
                    ValsSec = param.ToString();
                    break;
                case N1700Lib.WM_N1700_Switch:
                    if (param > 0) LedSwitch = "Lime";
                    else LedSwitch = "Gray";
                    break;
                case N1700Lib.WM_N1700_Communication:
                    break;
 
            }
        }
 
        unsafe public void DataCallback(int numChannels, IntPtr pChannelIdxArray, IntPtr pData, IntPtr context)
        {
            if (Environment.TickCount > LastTick + 10)
            {
                int[] ChIdxArray = new int[numChannels];
                double[] DataArray = new double[numChannels];
 
                Marshal.Copy(pChannelIdxArray, ChIdxArray, 0, numChannels);
                Marshal.Copy(pData, DataArray, 0, numChannels);
 
                GetMeasureResult = DataArray[1];
 
                tbResult.Text = GetMeasureResult.ToString(); //------------- ВЫВОД ДАННЫХ НА ЭКРАН -----------------
 
                LastTick = Environment.TickCount;
            }
        }
 
        unsafe public void RegisterDataCallback()
        {
            int i;
            uint[] pChannelIdxArray = new uint[MaxChannelCount];
            IntPtr pContext = new IntPtr(0);
 
            for (i = 0; i < NumChannels; i++)
            {
                pChannelIdxArray[i] = aN1700_Channel[i].ChannelIdx;
            }
            DCallback = new N1700Lib.N1700DataCallback(DataCallback);
            N1700Lib.N1700RegisterDataCallback(DCallback, (int)NumChannels, pChannelIdxArray, pContext);
        }
 
        unsafe public void GetModulesData()
        {
            uint i, q;
            IntPtr ptr;
 
            for (i = 0; i < NumModules; i++)
                if (i < MaxModuleCount)
                {
                    ptr = Marshal.AllocHGlobal(Marshal.SizeOf(aN1700_Module[i]));
                    iResult = N1700Lib.N1700GetModule(i, ptr);
                    aN1700_Module[i] = (N1700Lib.sN1700_Module)Marshal.PtrToStructure(ptr, typeof(N1700Lib.sN1700_Module));
 
                }
        }
 
        unsafe public void GetChannelsData()
        {
            uint i, q;
            IntPtr ptr;
 
            for (i = 0; i < NumChannels; i++)
                if (i < MaxChannelCount)
                {
                    ptr = Marshal.AllocHGlobal(Marshal.SizeOf(aN1700_Channel[i]));
                    iResult = N1700Lib.N1700GetChannel(i, ptr);
                    aN1700_Channel[i] = (N1700Lib.sN1700_Channel)Marshal.PtrToStructure(ptr, typeof(N1700Lib.sN1700_Channel));
                    if (aN1700_Channel[i].ChannelIdx == 0)
                    {
 
                    }
                }
            for (i = NumChannels; i < MaxChannelCount; i++)
                for (q = 0; q <= 5; q++)
 
            if (DataCallbackRegistered) N1700Lib.N1700UnregisterDataCallback(DCallback);
            RegisterDataCallback();
            DataCallbackRegistered = true;
 
            N1700Lib.N1700RequestAllData(0);
        }
 
        void StartStop()
        {
            if (!Measuring)
            {
                N1700Lib.N1700StartContinuousRequestAllData(0, 0);
                StatusMeasure = "On";
            }
            else
            {
                N1700Lib.N1700StopContinuousRequestAllData();
                StatusMeasure = "Off";
            }
            Measuring = !Measuring;
        }
 
        void GetCalib()
        {
            float fOffsetMM = 0;
            float fDigitsToMM = 0;
            float fGain = 0;
            bool bIsActive = false;
 
            N1700Lib.N1700GetCustomerCalibration(1, ref fOffsetMM, ref fDigitsToMM, ref fGain, ref bIsActive);
        }
    }
}