diff --git a/src/main/csharp/_TODO_.txt b/src/main/csharp/_TODO_.txt
deleted file mode 100644
index d14384c..0000000
--- a/src/main/csharp/_TODO_.txt
+++ /dev/null
@@ -1,29 +0,0 @@
- ~ BytesMessage.cs				// Ajouter commentaires
- X Connection.cs
- X ConnectionFactory.cs
- X ConnectionMetaData.cs
- X Destination.cs
- X InitialContext.cs
- X MapMessage.cs
- X Message.cs
- ~ MessageConsumer.cs			// Ajouter commentaires
- ~ MessageProducer.cs			// Ajouter commentaires
- ~ MessageProperties.cs			// Ajouter commentaires
- X ObjectMessage.cs
- X Queue.cs
- ~ QueueBrowser.cs				// Ajouter commentaires
- ~ Session.cs					// Ajouter commentaires
- X StreamMessage.cs
- X TemporaryQueue.cs
- X TemporaryTopic.cs
- X TextMessage.cs
- X Topic.cs
- ? Util\Dispatcher.cs
- X Util\ExceptionUtil.cs
- X Util\IntrospectionSupport.cs
- X Util\UriAttributeAttribute.cs
- X Util\XMSConvert.cs
- X Util\XMSEnum.cs
-
-
-Temporary Queue / Topic
\ No newline at end of file
