using (sqlConnection = new SqlConnection(connectionString))
{
	var serverConnection = new ServerConnection(sqlConnection);
	var server = new Server(serverConnection);
	var login = new Login(server, username) { LoginType = LoginType.SqlLogin };

	login.ChangePassword(oldPassword, newPassword);
}

using (sqlConnection = new SqlConnection(connectionString))
{
	//var sqlCommand = new SqlCommand("ALTER LOGIN [@username] WITH PASSWORD=[@password]", sqlConnection);
	var sqlCommand = new SqlCommand("ALTER LOGIN [@username] WITH PASSWORD = [@password] OLD_PASSWORD = [@oldPassword]", sqlConnection);

	sqlCommand.Parameters.Add("@username", SqlDbType.NVarChar);
	sqlCommand.Parameters["@username"].Value = username;
	
	sqlCommand.Parameters.Add("@password", SqlDbType.NVarChar);
	sqlCommand.Parameters["@password"].Value = newPassword;

	sqlCommand.Parameters.Add("@oldPassword", SqlDbType.NVarChar);
	sqlCommand.Parameters["@oldPassword"].Value = oldPassword;

	sqlConnection.Open();

	sqlCommand.ExecuteNonQuery();

	sqlConnection.Close();
}

private void tbConsole_KeyPress(object sender, KeyPressEventArgs e)
        {

            if (e.KeyChar == (Char)Keys.Return)
            {
                string TextInput = tbConsole.Text.ToString();

                rtbConsole.Text += TextInput;
                tbConsole.Text = "";
            }
        }

ServiceController serviceController = new ServiceController("ServiceName", Environment.MachineName);
                if (serviceController.Status.Equals(ServiceControllerStatus.Stopped) || serviceController.Status.Equals(ServiceControllerStatus.StopPending))
                {
                    serviceController.Start();
                    serviceController.WaitForStatus(ServiceControllerStatus.Running, new TimeSpan(0, 0, 0, 30));
                }

ServiceInstaller serviceInstaller = new ServiceInstaller();

                    String path = String.Format("/assemblypath={0}", _pathToService);
                    _logger.Debug(string.Format("Assemblypath: {0}", _pathToService));
                    String[] cmdline = { path };

                    InstallContext installContext = new InstallContext("", cmdline);

private void InstallService()
        {
            try
            {
                _logger.Info("Starting: Install Service");
                if (!IsServiceRunning(ServiceName))
                {
                    string serviceAccountString = ConfigurationManager.AppSettings["ServiceAccount"];
                    ServiceAccount serviceAccountType = ServiceAccount.User;
                    string serviceAccountUser = ConfigurationManager.AppSettings["ServiceAccountUser"];
                    string serviceAccountPassword = ConfigurationManager.AppSettings["ServiceAccountPassword"];

                    switch (serviceAccountString)
                    {
                        case "LocalService":
                            serviceAccountType = ServiceAccount.LocalService;
                            break;
                        case "LocalSystem":
                            serviceAccountType = ServiceAccount.LocalSystem;
                            break;
                        case "NetworkService":
                            serviceAccountType = ServiceAccount.NetworkService;
                            break;
                        case "User":
                            serviceAccountType = ServiceAccount.User;
                            break;
                    }

                    _logger.Debug("ServiceAccount Type: " + serviceAccountType);

                    ServiceProcessInstaller serviceProcessInstaller = new ServiceProcessInstaller() { Account = serviceAccountType };

                    if (!string.IsNullOrEmpty(serviceAccountUser) && !string.IsNullOrEmpty(serviceAccountPassword))
                    {
                        _logger.Info(string.Format("ServiceAccount User: {0}", serviceAccountUser));
                        serviceProcessInstaller.Username = serviceAccountUser;
                        serviceProcessInstaller.Password = serviceAccountPassword;
                    }
                    else
                    {
                        serviceProcessInstaller.Username = null;
                        serviceProcessInstaller.Password = null;
                    }

                    ServiceInstaller serviceInstaller = new ServiceInstaller();

                    String path = String.Format("/assemblypath={0}", _pathToService);
                    _logger.Debug(string.Format("Assemblypath: {0}", _pathToService));
                    String[] cmdline = { path };

                    InstallContext installContext = new InstallContext("", cmdline);

                    serviceInstaller.Context = installContext;
                    serviceInstaller.DisplayName = DisplayName;
                    serviceInstaller.ServiceName = ServiceName;
                    serviceInstaller.Description = ServiceDescription;

                    serviceInstaller.StartType = ServiceStartMode.Automatic;

                    serviceInstaller.Parent = serviceProcessInstaller;

                    ListDictionary state = new ListDictionary();
                    serviceInstaller.Install(state);

                    _logger.Info("Service install success");

                }
                else
                {
                    _logger.Info("Service is always started");
                }
            }
            catch (Exception ex)
            {
                _logger.Error("Error at Install Service", ex);
            }
        }

public void StartService()
        {
            try
            {
                _logger.Info("Start Service");
                ServiceController serviceController = new ServiceController(ServiceName, Environment.MachineName);
                if (serviceController.Status.Equals(ServiceControllerStatus.Stopped) || serviceController.Status.Equals(ServiceControllerStatus.StopPending))
                {
                    serviceController.Start();
                    serviceController.WaitForStatus(ServiceControllerStatus.Running, new TimeSpan(0, 0, 0, 30));
                }
            }
            catch (System.ServiceProcess.TimeoutException ex)
            {
                _logger.Error("Operation timed out", ex);
            }
            catch (UnauthorizedAccessException ex)
            {
                _logger.Error("You are not authorized to perform this action", ex);
            }
            catch (InvalidOperationException ex)
            {
                Win32Exception winEx = ex.InnerException as Win32Exception;
                if (winEx != null)
                {
                    switch (winEx.NativeErrorCode)
                    {
                        case 5: //ERROR_ACCESS_DENIED
                            _logger.Error("You are not authorized to perform this action", ex);
                            break;
                        case 1722: //RPC_S_SERVER_UNAVAILABLE
                            _logger.Error("The server is unavailable or does not exist", ex);
                            break;
                        case 1060: //ERROR_SERVICE_DOES_NOT_EXIST
                            _logger.Error("The service does not exist", ex);
                            break;
                        case 1056: //ERROR_SERVICE_ALREADY_RUNNING
                            _logger.Error("The service is already running", ex);
                            break;
                        case 1062: //ERROR_SERVICE_NOT_ACTIVE
                            _logger.Error("The service is not running", ex);
                            break;
                        default:
                            break;
                    }
                }
                _logger.Error("InvalidOperationException at Start service", ex);
            }
            catch (Exception ex)
            {
                _logger.Error("Error at start Service", ex);
            }
        }

System.ServiceProcess.ServiceBase.Run(program);

[WebGet]
public MeinComplexerType GetData(string clientId)
{
  return new MeinComplexerType(){id = 1, name = "Test"};
}

dc.BeginExecute<MeinComplexerType>(uriBuilder.Uri, (result) =>
            {
                string errorMessage = null;
                try
                {
                    var response = dc.EndExecute<MeinComplexerType>(result) as QueryOperationResponse<MeinComplexerType>;

                    if (response != null && response.Error != null)
                    {
                        errorMessage = "Fehler" + Environment.NewLine + response.Error.Message;
                    }

                    if (response != null)
                    {
                        var data= response.GetEnumerator();
                    }
                }
                catch (DataServiceQueryException ex)
                {
                    errorMessage = "Exception" + Environment.NewLine + ex.Message;
                }
            }, null);

Ping ping = new Ping();
PingReply reply = ping.Send(addrOrHost, 5000);

var rd = new ResourceDictionary()
                         {
                             Source = new Uri("/TestApp;component/Resources/Resources.xaml", UriKind.Relative)
                         };

return rd["Style"] as Style;