public static RobocopyResult RunRobocopy(string script)
        {
            using (var runspace = RunspaceFactory.CreateRunspace())
            {
                runspace.Open();

                var robo = @"$RC_Results = " + script + @"
                             $RC_Summary = $RC_Results | Select-Object -Last 7 | Select-Object -First 5
                             $RC_Summary[0] = 'Type' + $RC_Summary[0]
                             $RC_Summary[-1] = $RC_Summary[-1].Insert(39, 'N/A').Insert(49, 'N/A')
                             $NewRC_Summary = @()
                             foreach ($Line in $RC_Summary)
                             {
                                 $NewLine = $Line.Trim()
                                 $NewLine = $NewLine.Replace(' :', '')
                                 $NewLine = $NewLine -replace '\s{2,}', ' '
                                 $NewLine = $NewLine -replace '(\d)\s([bkmg])', '$1$2'
                                 $NewLine = $NewLine.Replace(' ', ',')
                                 $NewRC_Summary += $NewLine
                             }
                             $RC_Summary_Object = $NewRC_Summary | ConvertFrom-Csv
                             $RC_Summary_Object | Format-Table";

                var scriptInvoker = new RunspaceInvoke(runspace);
                //scriptInvoker.Invoke("Set-ExecutionPolicy Unrestricted");

                var pipeline = runspace.CreatePipeline();

                pipeline.Commands.AddScript(robo);

                pipeline.Commands.Add("Out-String");

                var results = pipeline.Invoke();

                runspace.Close();

                var stringBuilder = new StringBuilder();
                foreach (var obj in results)
                {
                    stringBuilder.AppendLine(obj.ToString());
                }

                var text = stringBuilder.ToString();

                var lines = text.Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
                var dirs = lines[2].Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                var files = lines[3].Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                var sizes = lines[4].Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                var times= lines[5].Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);

                return new RobocopyResult()
                {
                    TotalDirs = long.Parse(dirs[1]),
                    TotalFiles = long.Parse(files[1]),
                    TotalSize = sizes[1],
                    TotalTimes = times[1],

                    CopiedDirs = long.Parse(dirs[2]),
                    CopiedFiles = long.Parse(files[2]),
                    CopiedSize = sizes[2],
                    CopiedTimes = times[2],

                    SkippedDirs = long.Parse(dirs[3]),
                    SkippedFiles = long.Parse(files[3]),
                    SkippedSize = sizes[3],
                    SkippedTimes = times[3],

                    MismatchDirs = long.Parse(dirs[4]),
                    MismatchFiles = long.Parse(files[4]),
                    MismatchSize = sizes[4],
                    MismatchTimes = times[4],

                    FailedDirs = long.Parse(dirs[5]),
                    FailedFiles = long.Parse(files[5]),
                    FailedSize = sizes[5],
                    FailedTimes = times[5],

                    ExtraDirs = long.Parse(dirs[6]),
                    ExtraFiles = long.Parse(files[6]),
                    ExtraSize = sizes[6],
                    ExtraTimes = times[6]
                };
            }

            using (var ps = PowerShell.Create())
            {
                ps.Commands.AddScript("Import-Module Storage");

                ps.Commands.AddScript("Get-Disk");
                //ps.Commands.AddCommand("Out-String");

                var results = ps.Invoke();

                var stringBuilder = new StringBuilder();
                foreach (var obj in results)
                {
                    stringBuilder.AppendLine(obj.ToString());
                }

                var text = stringBuilder.ToString();
            }

                    Computer comp = context.Computer
                        .Expand("License")
                        .Expand("Hardware")
                        .Expand("Process")
                        .Expand("Version")
                        .Expand("Address")
                        .Expand("Settings")
                        .Expand("Database")
                        //.Expand("Database/Tables")
                        .Expand("Service")
                        .Expand("Printers")
                        .Where(c => c.CPUID == HardwareHelper.CpuId).FirstOrDefault();

if (txtBox != null)
	txtBox.TextChanged -= txtBox_TextChanged;

txtBox.?TextChanged -= txtBox_TextChanged;

        [DllImport("advapi32.dll", EntryPoint = "OpenSCManagerW", ExactSpelling = true, CharSet = CharSet.Unicode, SetLastError = true)]
        static extern IntPtr OpenSCManager(string machineName, string databaseName, ScmAccessRights dwDesiredAccess);

        [DllImport("advapi32.dll", SetLastError = true, CharSet = CharSet.Auto)]
        static extern IntPtr OpenService(IntPtr hSCManager, string lpServiceName, ServiceAccessRights dwDesiredAccess);

        [DllImport("advapi32.dll", SetLastError = true, CharSet = CharSet.Auto)]
        private static extern IntPtr CreateService(IntPtr hSCManager, string lpServiceName, string lpDisplayName, ServiceAccessRights dwDesiredAccess, int dwServiceType, ServiceBootFlag dwStartType, ServiceError dwErrorControl, string lpBinaryPathName, string lpLoadOrderGroup, IntPtr lpdwTagId, string lpDependencies, string lp, string lpPassword);

        public static bool Install(string serviceName, string displayName, string fileName, ServiceBootFlag bootOption)
        {
            IntPtr scm = OpenSCManager(ScmAccessRights.AllAccess);

            try
            {
                IntPtr service = OpenService(scm, serviceName, ServiceAccessRights.AllAccess);

                if (service == IntPtr.Zero)
                    service = CreateService(scm, serviceName, displayName, ServiceAccessRights.AllAccess, SERVICE_WIN32_OWN_PROCESS, bootOption, ServiceError.Normal, fileName, null, IntPtr.Zero, null, null, null);

                if (service == IntPtr.Zero)
                    throw new ApplicationException("Failed to install service.");

                return true;
            }
            finally
            {
                CloseServiceHandle(scm);
            }
        }

comp.Database.Tables.Add(tab);
                        context.AddToTable(tab);

//context.AddRelatedObject(tab, "Tables", comp.Database);
                        //context.AddLink(tab, "Tables", comp.Database);

        public static WS_Test.GB CreateContext()
        {
            var context = new WS_Test.GB(new Uri(WebBase.GBWebServiceUrl));
            context.Timeout = 15;
            context.SendingRequest2 += context_SendingRequest2;

            return context;
        }

                var context = WebBase.CreateContext();
                
                Computer comp = context.Computer
                    .Expand("License") 
                    .Expand("Hardware")
                    .Expand("Process")
                    .Expand("Version")
                    .Expand("Address")
                    .Expand("Settings")
                    .Expand("Database")
                    .Expand("Service")
                    .Expand("Printers")
                    .Where(c => c.CPUID == settings.ComputerId).FirstOrDefault();

                if (comp.Database == null)
                {
                    comp.Database = new Database();
                    context.AddToDatabase(comp.Database);
                    context.AddLink(comp.Database, "Computers", comp);
                }

                foreach (var row in DBInfo.GetTablesInfo().ResultSet[0].Rows)
                {
                    var name = row.Values[1].ToString();
                    var tab = comp.Database.Tables.Where(t => t.Name == name).FirstOrDefault();

                    if (tab == null)
                    {
                        tab = new Table();
                        tab.Name = name;
                        tab.Database = comp.Database;
                       
                        comp.Database.Tables.Add(tab);
                        context.AddToTable(tab);
                        //context.AddRelatedObject(tab, "Tables", comp.Database);
                        //context.AddLink(tab, "Tables", comp.Database);
                    }
                    tab.Bytes = Convert.ToInt64(row.Values[4]);
                }

                NetworkHelper.TrustAllSSL();

                using (var wc = new ExtendedWebClient())
                {
                    wc.Headers[HttpRequestHeader.ContentType] = "application/json";
                    wc.Headers.Add(HttpRequestHeader.Accept, "application/json");
                    return wc.DownloadString(url);
                }

    public class ExtendedWebClient : WebClient
    {
        public int Timeout { get; set; }

        public ExtendedWebClient()
        {
            Timeout = 5000;
        }
        protected override WebRequest GetWebRequest(Uri address)
        {
            var wc = base.GetWebRequest(address);
            wc.Timeout = Timeout;
            return wc;
        }
    }

        public static void TrustAllSSL()
        {
            ServicePointManager.ServerCertificateValidationCallback = delegate { return true; };
        }

            timer = new Timer { Interval = AlertInterval };
            timer.Tick += CheckAlerting;

        private void CheckAlerting(object sender, EventArgs e)
        {
            if (isChecking) return;

            isChecking = true;

            Task.Factory.StartNew(() =>
            {
                CollectInformation();
                DoOutput();
            });
        }

                PlaySound(fileSumSound);
                foreach (var info in _alertsSum)
                    _alertSum.Show(Manager.Form, info);

                PlaySound(fileFahrerSound);
                foreach (var info in _alertsFahrer)
                    _alertFahrer.Show(Manager.Form, info);

                PlaySound(fileOrderSound);
                foreach (var ai in _alertsOrder)
                    _alertOrder.Show(Manager.Form, ai);

                foreach (var trigger in MsgBoxList)
                    ShowErorForm(uow, Manager, trigger);

                isChecking = false;

Source        : Microsoft.Data.Services.Client -> HandleResponse
Computer      : 04.07.2015 12:07:05 -> Rechner2 Verion: 1.6.3.63
Error         : Fehler beim Verarbeiten dieser Anforderung.
Stack Trace   : at System.Data.Services.Client.SaveResult.HandleResponse()
   at System.Data.Services.Client.BaseSaveResult.EndRequest()
   at System.Data.Services.Client.DataServiceContext.SaveChanges(SaveChangesOptions options)

                WebService_V7 context = new WebService_V7(new Uri(WebBase.Url));
                Computer comp = context.Computer.Where(c => c.ID == settings.ID).FirstOrDefault();

                if (comp == null) return "";

                comp.Date = DateTime.Now;

                context.UpdateObject(comp);
                context.SaveChanges();

        public static String GenerateMachineID()
        {
            var check = new[,]
            {
                {"Win32_NetworkAdapterConfiguration", "MACAddress"},
                {"Win32_Processor", "UniqueId"},
                {"Win32_Processor", "ProcessorId"},
                {"Win32_Processor", "Name"},
                {"Win32_Processor", "Manufacturer"}
            };

            //WMI query
            const string query = "SELECT {1} FROM {0}";
            const string queryex = " WHERE IPEnabled = 'True'";
            var sb = new StringBuilder();

            for (var i = 0; i < check.GetLength(0); i++)
            {
                using (var oWMI = new ManagementObjectSearcher(
                    string.Format(query, check[i, 0], check[i, 1]) + (i == 0 ? queryex : string.Empty)))
                {
                    foreach (var o in oWMI.Get())
                    {
                        var mo = (ManagementObject) o;
                        var result = mo[check[i, 1]] as string;
                        if (result != null) sb.AppendLine(result);
                        break;
                    }
                }
            }

            using (MD5 sec = new MD5CryptoServiceProvider())
            {
                var enc = new ASCIIEncoding();
                var bt = enc.GetBytes(sb.ToString());
                bt = sec.ComputeHash(bt);
                sb.Clear();
                foreach (byte t in bt)
                {
                    sb.AppendFormat("{0:X2}", t);
                }
            }

            return sb.ToString();
        }