using System.ServiceModel;

[ServiceContract]
public interface IMonPremierServiceWCF
{
	[OperationContract]
	void EcrireUnePhrase(string phrase);
}

[DataContract]
public class MyDatas
{
	private string data1
	
	[DataMember]
	public string Data1
	{
		get
		{
			return this.data1;
		}
		
		set
		{
			this.data1 = value;
		}	
	}
}

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
	<system.serviceModel>
		<services>
			<service name="DvpDemoWCF.IMonPremierServiceWCF">
				<endpoint address="net.tcp://localhost:5000/DvpDemoWCF" binding="netTcpBinding" contract="DvpDemoWCF.IMonPremierServiceWCF"/>
			</service>
		</services>
	</system.serviceModel>
</configuration>

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
	<system.serviceModel>
		<services>
			<service name="DvpDemoWCF.IMonPremierServiceWCF">
				<endpoint address="net.tcp://localhost:5000/DvpDemoWCF" binding="netTcpBinding" contract="DvpDemoWCF.IMonPremierServiceWCF"/>
			</service>
		</services>
	</system.serviceModel>
</configuration>

/// <summary>
/// Interface de définition du service distant
/// </summary>
[ServiceContract]
public interface RemoteService
{

    /// <summary>
    /// Identifie le client sur le serveur.
    /// </summary>
    /// <param name="clientInformation">Les informations d'identification du client</param>
    [OperationContract]
	void IdentifyClient(ClientInformation clientInformation);

   	/// <summary>
   	/// Obtient la liste des logiciels à installer sur le client
   	/// </summary>
   	/// <returns></returns>
   	[OperationContract]
	List<SoftwareData> GetSoftwareList();

   	/// <summary>
   	/// Renvois le rapport d'installation au serveur afin de centraliser l'information
   	/// </summary>
   	/// <param name="clientReport">le rapport du client sur l'installation des logiciels</param>
   	[OperationContract]
	void UploadReport(ClientReport clientReport);

}

/// <summary>
/// Classe représentant un logiciel devant être installé sur le poste client
/// </summary>
[DataContract]
public class SoftwareData
{

    private string name;
    private string installerAddress;
    private Version version;

    /// <summary>
    /// Constructeur par défaut
    /// </summary>
    public SoftwareData()
    {

    }

    #region Proprietes

    /// <summary>
    /// Obtient ou défini le nom du logiciel à installer
    /// </summary>
    [DataMember]
    public string Name
    {
        get
        {
            return this.name;
        }

        set
        {
            this.name = value;
        }
    }

    /// <summary>
    /// Obtient ou défini l'adresse de l'installeur
    /// </summary>
    [DataMember]
    public string InstallerAddress
    {
        get
        {
            return this.installerAddress;
        }

        set
        {
            this.installerAddress = value;
        }
    }

    /// <summary>
    /// Obtient ou défini la version du logiciel à installer
    /// </summary>
    [DataMember]
    public Version Version
    {
        get
        {
            return this.version;
        }

        set
        {
            this.version = value;
        }
    }

    #endregion

}

/// <summary>
/// Classe définissant un rapport suite à l'installation de logiciel sur le client
/// </summary>
[DataContract]
public class ClientReport
{

    private DateTime date;

    [DataMember]
    public DateTime Date
    {
        get { return date; }
        set { date = value; }
    }

    private string clientName;

    public string ClientName
    {
        get { return clientName; }
        set { clientName = value; }
    }

    private List<SoftwareInstallReport> installReports;

    public List<SoftwareInstallReport> InstallReports
    {
        get { return installReports; }
        set { installReports = value; }
    }


}

public void Main(string[] args)
{
    remoteService = new RemoteService();

    //Publication de la classe en singleton
    host = new ServiceHost(remoteService);

    //Ouverture du canal de communication
	host.Open();
}

//Fermeture du canal de communication
host.Close();

[ServiceBehavior(InstanceContextMode = InstanceContextMode.Single, ConcurrencyMode = ConcurrencyMode.Single)]
public class RemoteService : IRemoteService
{

    private Dictionary<string, ClientInformation> clientInformations;
    private List<string> clientAuthentified;

    /// <summary>
    /// Constructeur par défaut
    /// </summary>
    public RemoteService()
    {
        this.clientInformations = new Dictionary<string, ClientInformation>();
        this.clientAuthentified = new List<string>();

        //DEBUG
        ClientInformation ci = new ClientInformation();
        ci.ClientVersion = new Version("1.0.0.0");
        ci.Name = "dev01";

        this.clientInformations.Add(ci.Name, ci);
    }

    #region IRemoteService Members

    public void IdentifyClient(ClientInformation clientInformation)
    {
        if ( !clientInformations.ContainsKey(clientInformation.Name))
        {
            throw new Exception("Client inconnu !");
        }

        if (clientAuthentified.Contains(clientInformation.Name))
            throw new Exception("Client déjà authentifié");

        this.clientAuthentified.Add(clientInformation.Name);
    }

    public List<SoftwareData> GetSoftwareList(ClientInformation clientInformation)
    {
        if (this.clientAuthentified.Contains(clientInformation.Name))
        {
            //DEBUG
            SoftwareData soft = new SoftwareData();
            soft.InstallerAddress = "\\myserver\partage\setup.exe";
            soft.Name = "Test";
            soft.Version = new Version("0.0.0.1");

            List<SoftwareData> lists = new List<SoftwareData>();
            lists.Add(soft);

            return lists;
        }
        else
        {
            throw new Exception("Client non authentifié");
        }
    }

    public void UploadReport(ClientReport clientReport)
    {
            
    }

    #endregion
}

/// <summary>
/// Service client récupérant la liste des softs à installer sur le client
/// </summary>
public partial class SoftwareInstallerClientService 
{

    private ChannelFactory<IRemoteService> channelFactory;
    private IRemoteService remoteSerice;
    private System.Timers.Timer timer;
    private ClientInformation clientInformation;

    public event UpdateNeededProgramEventHandler UpdateNeededProgram;

    public SoftwareInstallerClientService()
    {
            
    }

    public void Start()
    {
        channelFactory = new ChannelFactory<IRemoteService>("SI");
        channelFactory.Open();

        remoteSerice = channelFactory.CreateChannel();

        clientInformation = new ClientInformation();
        clientInformation.ClientVersion = new Version("1.0.0.0");
        clientInformation.Name = "dev01";
        clientInformation.UserName = Environment.UserName;

        //Envoi de l'authentification au serveur
        remoteSerice.IdentifyClient(clientInformation);

        //Timer toute les 5 minutes
        timer = new System.Timers.Timer(6000);
        timer.Elapsed += new ElapsedEventHandler(timer_Elapsed);
        timer.Enabled = true;
            
    }

    void timer_Elapsed(object sender, ElapsedEventArgs e)
    {
        List<SoftwareData> softs = remoteSerice.GetSoftwareList(clientInformation);

        if (this.UpdateNeededProgram != null)
            this.UpdateNeededProgram(softs);
    }

    public void Stop()
    {
        timer.Enabled = false;

        channelFactory.Close();    
	}
}