Estoy haciendo un programa que envie e-mail cuando se logueen con usuario Administrador y cuando cambien la IP, pero tengo un problema, al loguearme con cualquier usuario me llega el e-mail de logueo de usuario Administrador, yo estoy creando un servicio de windows que se inicia con usuario Administrador, porque como "cuenta local" no envia ningún e-mail, ayuda por favor:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Linq;
using System.ServiceProcess;
using System.Text;
using System.Timers;
using System.Runtime.InteropServices;
using System.Net;
using System.Net.NetworkInformation;
//using Microsoft.Win32;
using System.Security.Principal;
using System.Threading;

namespace Monitor_de_Actividad_ITT
{
public partial class ServicioMonitorActividadITT : ServiceBase
{

System.Timers.Timer testTimer = new System.Timers.Timer();
string str_iniciado_primera_vez = "SI";
string str_ip_primera_vez = GetLocalIPv4(NetworkInterfaceType.Ethernet);
public string str_usuario = string.Empty;
public string str_hostname = string.Empty;
public string notificaAdministrator = "NO";
public static string usuario = string.Empty;

public ServicioMonitorActividadITT()
{

InitializeComponent();
eventLog1 = new System.Diagnostics.EventLog();
if (!System.Diagnostics.EventLog.SourceExists("Monito rActividadITT"))
{
System.Diagnostics.EventLog.CreateEventSource(
"MonitorActividadITT", "LogMonitorActividadITT");
}
eventLog1.Source = "MonitorActividadITT";
eventLog1.Log = "LogMonitorActividadITT";

}

//public void OnStart(string[] args) // colcoar este para debug en desarrollo
protected override void OnStart(string[] args) //esto se debe dejar asi y quitar el modo debug
{

#region Estado de inicio pendiente
//implementar el estado Inicio pendient
// Update the service state to Start Pending.
ServiceStatus serviceStatus = new ServiceStatus();
serviceStatus.dwCurrentState = ServiceState.SERVICE_START_PENDING;
serviceStatus.dwWaitHint = 100000;
SetServiceStatus(this.ServiceHandle, ref serviceStatus);
#endregion


if (str_iniciado_primera_vez == "SI")
{
eventLog1.WriteEntry("Servicio MonitorActividadITT Iniciado");
str_iniciado_primera_vez = "NO";
}

ServicioMonitorActividadITT timer = new ServicioMonitorActividadITT();
timer.testTimer.Enabled = true;

timer.testTimer.Interval = 60000; // 1 minuto
//timer.testTimer.Interval = 6000; // solo segundos
//System.Console.WriteLine(".......entro");//quitar

timer.testTimer.Elapsed += new System.Timers.ElapsedEventHandler(timer.testTimer_ Elapsed);

#region verifica si es administrador
// version anterior de israel, comentada

notificaAdministrator = "NO";

Thread thread = new Thread(new ThreadStart(EsUserAdministrador));
thread.Start();

try
{
usuario = System.Security.Principal.WindowsIdentity.GetCurre nt().Name;
}
catch (Exception)
{
usuario = string.Empty;
}

//// nueva version
//Thread thread = new Thread(new ThreadStart(EsUserAdministrador_nuevo));
//thread.Start();
#endregion

#region Estado de inicio pendiente - finalizacion
//
// Update the service state to Running.
serviceStatus.dwCurrentState = ServiceState.SERVICE_RUNNING;
SetServiceStatus(this.ServiceHandle, ref serviceStatus);
#endregion

}

protected override void OnStop()
{
eventLog1.WriteEntry("Servicio MonitorActividadITT Detenido");
}

protected override void OnContinue()
{
eventLog1.WriteEntry("Servicio MonitorActividadITT Reiniciado");
}

/*
//Controla el tiempo de monitoreo
public void OnTimer(object sender, System.Timers.ElapsedEventArgs args)
{
// TODO: Insert monitoring activities here.
eventLog1.WriteEntry("Monitoring the System", EventLogEntryType.Information);//, eventId++);
}
* */

/*
* Los servicios informan de su estado al Administrador de control de servicios,
* para que los usuarios puedan saber si un servicio funciona correctamente.
* De manera predeterminada, los servicios que se heredan de ServiceBase informan
* de un conjunto limitado de parámetros de estado, incluidos Detenido, En pausa
* y En ejecución.Si un servicio tarda un poco en iniciarse, puede ser útil
* informar de un estado Inicio pendiente.También puede implementar la configuración
* de estado Inicio pendiente y Detención pendiente si agrega código que llama a la
* función SetServiceStatus de Windows.
*/
public enum ServiceState
{
SERVICE_STOPPED = 0x00000001,
SERVICE_START_PENDING = 0x00000002,
SERVICE_STOP_PENDING = 0x00000003,
SERVICE_RUNNING = 0x00000004,
SERVICE_CONTINUE_PENDING = 0x00000005,
SERVICE_PAUSE_PENDING = 0x00000006,
SERVICE_PAUSED = 0x00000007,
}

[StructLayout(LayoutKind.Sequential)]
public struct ServiceStatus
{
public long dwServiceType;
public ServiceState dwCurrentState;
public long dwControlsAccepted;
public long dwWin32ExitCode;
public long dwServiceSpecificExitCode;
public long dwCheckPoint;
public long dwWaitHint;
};

[DllImport("advapi32.dll", SetLastError = true)]
private static extern bool SetServiceStatus(IntPtr handle, ref ServiceStatus serviceStatus);

private void testTimer_Elapsed(object sender,System.Timers.ElapsedEventArgs e)
{

//System.Console.WriteLine("Ingreso cada cierto time");//quitar

string str_error = string.Empty;
string ipv4 = string.Empty;
try
{
str_usuario = System.Security.Principal.WindowsIdentity.GetCurre nt().Name;
}
catch (Exception)
{
str_usuario = string.Empty;
}
try
{
str_hostname = GetHostName();
}
catch (Exception)
{
str_hostname = string.Empty;
}


ipv4 = GetLocalIPv4(NetworkInterfaceType.Ethernet);
if (str_ip_primera_vez != ipv4)
{
#region obtengo usuario windows
WindowsIdentity user = null;
string str_usuario_windows = string.Empty;
string str_usuario_windows_recortado = string.Empty;

try
{
user = WindowsIdentity.GetCurrent();
str_usuario_windows = user.Name;
str_usuario_windows_recortado = str_usuario_windows.Remove(0, str_usuario_windows.IndexOf("\\") + 1);
}
catch (Exception ex)
{
str_usuario_windows_recortado = "Error al obtener usuario";
}
#endregion
//System.Console.WriteLine("La ip cambio de : " + str_ip_primera_vez +" a "+ ipv4);
Mail obj_mail = new Mail();
obj_mail.EnviaMail(str_hostname, ipv4, str_ip_primera_vez, str_usuario_windows_recortado, out str_error);
str_ip_primera_vez = ipv4;
}

EsUserAdministrador();

}

internal static string GetLocalIPv4(NetworkInterfaceType _type)
{
string output = "";
foreach (NetworkInterface item in NetworkInterface.GetAllNetworkInterfaces())
{
if (item.NetworkInterfaceType == _type /*&& item.OperationalStatus == OperationalStatus.Up*/)
{
IPInterfaceProperties adapterProperties = item.GetIPProperties();

if (adapterProperties.GatewayAddresses.FirstOrDefault () != null)
{
foreach (UnicastIPAddressInformation ip in adapterProperties.UnicastAddresses)
{
if (ip.Address.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
{
output = ip.Address.ToString();
}
}
}
}
}

return output;
}

public static string GetHostName()
{
string host = string.Empty;
host = Dns.GetHostName();
return host;
}

public void EsUserAdministrador()
{
Mail m = new Mail();
bool esAdministrador; // si pertenece al grupo admnistradores
WindowsIdentity user = null;
string str_usuario_windows = string.Empty;
string str_usuario_windows_recortado = string.Empty;
string str_ip_actual = GetLocalIPv4(NetworkInterfaceType.Ethernet);

System.Console.WriteLine("ento : " + str_usuario_windows_recortado);

try
{
//string hostname = Environment.UserName;
user = WindowsIdentity.GetCurrent();
WindowsPrincipal principal = new WindowsPrincipal(user);
esAdministrador = principal.IsInRole(WindowsBuiltInRole.Administrato r);//usuario pertenece a grupo administradores
str_usuario_windows = user.Name;
str_usuario_windows_recortado = str_usuario_windows.Remove(0, str_usuario_windows.IndexOf("\\") + 1);
str_usuario_windows_recortado = Environment.UserName;
}
catch (UnauthorizedAccessException ex)
{
esAdministrador = false;
}
catch (Exception ex)
{
esAdministrador = false;
}
finally
{
if (user != null)
user.Dispose();
}

/*
System.Console.WriteLine("Usuario: " + str_usuario_windows);//quitar
System.Console.WriteLine("Ocurrencia: " + str_usuario_windows.IndexOf("\\"));//quitar
System.Console.WriteLine("Recortado: " + str_usuario_windows_recortado);//quitar
System.Console.WriteLine("es admin: " + esAdministrador);//quitar
*/

if (notificaAdministrator == "NO")
{
try
{
if (/*esAdministrador && */(str_usuario_windows_recortado.ToUpper() == "ADMINISTRATOR" || str_usuario_windows_recortado.ToUpper() == "ADMINISTRADOR"))
{
string error = string.Empty;
//System.Console.WriteLine("envio mail de administrador" + str_usuario_windows + " - " + str_ip_actual);//quitar
m.EnviaMail(str_usuario_windows, str_ip_actual, out error);
if (!string.IsNullOrEmpty(error))
{
eventLog1.WriteEntry(string.Format("MonitoreoIpUsu arios error envio mail usuario administador: {0} ", error));
}

eventLog1.WriteEntry(string.Format("MonitoreoIpUsu arios login usuario administador: {0}-{0}", str_usuario_windows, str_ip_actual));
notificaAdministrator = "SI";
}
}
catch (Exception) { }
}
}

//public void EsUserAdministrador_nuevo()
//{
// Mail m = new Mail();
// bool esAdministrador;
// WindowsIdentity user = null;
// try
// {
// user = WindowsIdentity.GetCurrent();
// WindowsPrincipal principal = new WindowsPrincipal(user);
// esAdministrador = principal.IsInRole(WindowsBuiltInRole.Administrato r);
// }
// catch (UnauthorizedAccessException ex)
// {
// esAdministrador = false;
// }
// catch (Exception ex)
// {
// esAdministrador = false;
// }
// finally
// {
// if (user != null)
// user.Dispose();
// }

// //eventLog1.WriteEntry(string.Format("MonitoreoIpUsu arios usuario administador: {0}", user.Name));

// if (notificaAdministrator == "NO")
// {
// try
// {
// if (esAdministrador && (user.Name == "Administrator" || user.Name == "Administrador"))
// {
// string error = string.Empty;

// m.Envia_Mail_Administrador(str_ip_primera_vez/*ip*/, out error);//iach se coloca ip obtenida en proceso anterior
// if (!string.IsNullOrEmpty(error))
// {
// eventLog1.WriteEntry(string.Format("MonitoreoIpUsu arios error envio mail usuario administador: {0} ", error));
// }
// notificaAdministrator = "SI";
// }
// }
// catch (Exception) { }
// }
//}

}
}