Discussion :

[demonia]

Bonjour,

J'aimerai créer un service qui exécute des actions en arrière plan et le lier à une interface graphique pour le contrôler.

J'ai déjà pas mal recherché sur le web mais je n'ai pas trouvé grand chose à part le fait de permettre l'interraction avec le bureau, mais cette solution ne me convient pas vraiment car elle n'est pas très propre à mon goût.

J'ai vu qu'il était aussi possible de le faire via le réseau (TCP/IP) mais j'aimerai savoir si ça serait possible sans passer par le réseau.

Je commence dans la programmation de services donc si quelqu'un aurait des exemples de codes (que se soit pour passer par le réseau ou non) qui me permettraient de voir quelque chose de propre, je lui en serait très reconnaissant.

Merci

[Pol63]

le plus propre serait surement le tcp/ip, qui peut etre simplifié dans le code par .net remoting par exemple

sinon une version simple c'est que le service rempli un fichier texte et l'autre exe le lit ... mais ca reste moyen et peut etre problématique au niveau des accès ...

[demonia]

le plus propre serait surement le tcp/ip, qui peut etre simplifié dans le code par .net remoting par exemple

Sinon une version simple c'est que le service rempli un fichier texte et l'autre exe le lit ... mais ca reste moyen et peut etre problématique au niveau des accès ...

Merci pour la réponse.
J'avais bien pensé au fichier texte avec un listener sur le fichier, mais comme ça serait une application serveur assez pointue, j'aimerais faire les choses de la manière la plus propre possible.

J'ai testé les connexions IPC avec le remoting mais j'ai eu des problèmes sous vista/seven/server 2008.

Voilà ce que j'ai essayé pour le moment si quelqu'un a une idée ou une alternative.

Pour le serveur (exécuté par le service), voilà les 2 principaux codes testés (j'ai fait pas mal d'autres tests, mais sans succès non plus) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
	[SecurityPermission(SecurityAction.Demand)]
	class RemoteServer {
		public RemoteServer() {
			//IPC port name
			IDictionary properties = new Hashtable();
 
			properties.Add("authorizedGroup", "Users");
			properties.Add("portName", "ServiceChannel");
			properties.Add("rejectRemoteRequests", true);
			properties.Add("name", "RemoteObject.rem");
 
			IpcChannel serverChannel = new IpcChannel(properties, null, null);
 
			ChannelServices.RegisterChannel(serverChannel, false);
			ChannelDataStore channelData =
			(ChannelDataStore)serverChannel.ChannelData;
			RemotingConfiguration.RegisterWellKnownServiceType(
				typeof(RemoteObject), "RemoteObject.rem",
				WellKnownObjectMode.Singleton);
		}
	}

et ce code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
	[SecurityPermission(SecurityAction.Demand)]
	class RemoteServer {
		public RemoteServer() {
			IpcChannel serverChannel = new IpcChannel("ServiceChannel");
 
			ChannelServices.RegisterChannel(serverChannel, false);
			ChannelDataStore channelData =
			(ChannelDataStore)serverChannel.ChannelData;
			RemotingConfiguration.RegisterWellKnownServiceType(
				typeof(RemoteObject), "RemoteObject.rem",
				WellKnownObjectMode.Singleton);
		}
	}

Le premier ne fonctionne pas, car la propriété authorizedGroup n'existe pas dans .NET 3.5 mais à priori c'est cette propriété qui est sensée permettre le fonctionnement sous vista/seven.

Le second code me donne le message d'erreur suivant pour le client :

Failed to connect to an IPC Port: Access is denied.

le client (qui n'est pas spécialement très utile pour le moment en partant du principe que le serveur ne fonctionne pas et qui lui sera exécuté par la partie GUI) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
[SecurityPermission(SecurityAction.Demand)]
class RemoteClient {
	ISharedAssemblyInterface service;
	public RemoteClient() {
		IpcChannel ipcCh = new IpcChannel("NonooAlertManagerClientChannel");
		ChannelServices.RegisterChannel(ipcCh, false);
 
		service = (Remoteable.ISharedAssemblyInterface)Activator.GetObject (typeof(Remoteable.ISharedAssemblyInterface), "ipc://ServiceChannel/RemoteObject.rem");
	}

et mon interface :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
namespace Remoteable {
	public interface ISharedAssemblyInterface {
		string Test();
	}
}

J'ai pas mal recherché sur google et je suis tombé sur pas mal de sites parlant de ce genre de choses mais soit les solutions ne fonctionnent pas, soit elles sont faites avec .NET 2.

[Pol63]

tout ce qui fonctionne sur .net 2 fonctionne nécessairement sur .net 3.5

j'ai déjà vu des tutos sur le remoting et le code ressemblait pas exactement à ca il me semble ...

sinon le remoting fonctionne sur vista c'est sur, et je pense qu'il fonctionne aussi sur 7 et server 2008

[demonia]

tout ce qui fonctionne sur .net 2 fonctionne nécessairement sur .net 3.5

J'ai déjà vu des tutos sur le remoting et le code ressemblait pas exactement à ca il me semble ...

Sinon le remoting fonctionne sur vista c'est sur, et je pense qu'il fonctionne aussi sur 7 et server 2008

J'ai testé une 10ène de tutos mais aucun n'a donné de résultat.
et même en application dos ça me mettait le message d'erreur sur seven/vista/2008.

En fait la propriété authorizedGroup n'existe plus dans le framework 3.5 à priori.
Je m'étais basé sur cette solution parce qu'il y avait le même problème que moi :
http://www.virtualroadside.com/blog/...windows-vista/

Par contre j'ai réussi à faire fonctionner avec TCP.
Merci pour l'aide, les indices m'ont bien aidé pour trouver la solution.

Pour ceux qui ont le même problème, voici la solution que j'ai utilisée (toute simple en plus) :

le serveur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
class TCPRemoteServer {
	public TCPRemoteServer() {
		TcpChannel tcpChannel = new TcpChannel(8148);
		ChannelServices.RegisterChannel(tcpChannel, false);
		Type commonInterfaceType = typeof(RemoteObject);
		RemotingConfiguration.RegisterWellKnownServiceType(commonInterfaceType, "ServerChannel", WellKnownObjectMode.Singleton);
	}
}

le client :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
class TCPRemoteClient {
	private ISharedAssemblyInterface remoteObject;
	public TCPRemoteClient() {
		TcpChannel tcpChannel = new TcpChannel();
		ChannelServices.RegisterChannel(tcpChannel);
 
		Type requiredType = typeof(ISharedAssemblyInterface);
		remoteObject = (ISharedAssemblyInterface) Activator.GetObject(requiredType, "tcp://localhost:8148/ServerChannel");
	}
	public string testRemote() {
		return remoteObject.Test();
	}
}

L'objet RemoteObject qui est utilisé avec le serveur et qui permettra de définir le code à exécuter :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
public class RemoteObject : MarshalByRefObject, ISharedAssemblyInterface {
	public RemoteObject() {}
 
	public String Test() {
		return "Test!!!";
	}
}

et l'interface (toute simple et ou il faut rajouter les méthodes qu'on veut utiliser) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
public interface ISharedAssemblyInterface {
	string Test();
}

Il est plus simple de mettre l'inteface dans une DLL à part pour pouvoir la mettre sur la partie server et client.

Voila j'espère que ça pourra en aider d'autres.