Naja, die üblichen verdächtigen: CodePlex, Code Project, Novell Forge, Google Code, ...

... ups, SourceForge vergessen 🙂

Das Programm ist auf jeden Fall OS (GPL). Du könntest die relevanten Komponenten nach .Net / C# portieren.

Was ist das für ein Router?

Zufällig eine Fritz!Box? Wenn ja, dann häng sie mit an den internen ISDN-Bus der TK-Anlage. Du kannst dann jFritz (mit Klingeling) übers Netzwerk nutzen.

http://msdn2.microsoft.com/de-de/library/system.double.parse(VS.80).aspx

Erläuterungen zum erlaubten Zahlenformat bei Nichtangabe von IFormatProvider / NumberStyles:

http://msdn2.microsoft.com/de-de/library/fd84bdyt(VS.80).aspx

Resharper kann das.

Das hat wahrscheinlich auch eher weniger mit C# zu tun. Er meint wahrscheinlich Citrix WinFrame. Mitlerweile nennt sich das Produkt jedoch Citrix Presentation Server.

Mit C++/CLI (der mit VS2005 eingeführte Nachfolger von managed C++) kannst du sog. mixed-mode assemblies erstellen, in denen unmanaged und managed Code vereint ist. Um die "Details im Hintergrund" kümmert sich der Compiler.

Siehe auch:

1. http://www.codeproject.com/managedcpp/cppcliintro01.asp
2. MSDN Library

Original von herbivore
Die Frage ist eher, wo ist die BuildArgumentOutOfRangeException-Methode definiert. Ich vermute in dem "(...)"-Teil.

Richtig: Es handelt sich um eine private Helfer-Methode der selben Klasse.

Hier ein Beispiel für einen ExceptionBuilder:

using System;
using System.Diagnostics.CodeAnalysis;
using System.Reflection;
using System.Security;
using System.Security.Permissions;
using EpiSource.Common.Resources;

namespace EpiSource.Common.ExceptionBuilders
{
	/// <summary>
	/// Builds common <seealso cref="ArgumentOutOfRangeException" />s with consistent exception messages.
	/// </summary>
	public static class ArgumentOutOfRangeExceptionBuilder
	{	
		
		// (...)

		#region BuildIndexOutOfRangeException

		/// <summary>
		/// (...)
		/// </summary>
		public static ArgumentOutOfRangeException BuildIndexOutOfRangeException()
		{
			return BuildIndexOutOfRangeException(null, null, null);
		}

		/// <summary>
		/// (...)
		/// </summary>
		public static ArgumentOutOfRangeException BuildIndexOutOfRangeException(string parameterName)
		{
			return BuildIndexOutOfRangeException(parameterName, null, null);
		}

		/// <summary>
		/// (...)
		/// </summary>
		public static ArgumentOutOfRangeException BuildIndexOutOfRangeException(object actualValue)
		{
			return BuildIndexOutOfRangeException(null, actualValue, null);
		}

		/// <summary>
		/// (...)
		/// </summary>
		public static ArgumentOutOfRangeException BuildIndexOutOfRangeException(Exception innerException)
		{
			return BuildIndexOutOfRangeException(null, null, innerException);
		}

		/// <summary>
		/// (...)
		/// </summary>
		public static ArgumentOutOfRangeException BuildIndexOutOfRangeException(string parameterName, object actualValue)
		{
			return BuildIndexOutOfRangeException(parameterName, actualValue, null);
		}

		/// <summary>
		/// (...)
		/// </summary>
		public static ArgumentOutOfRangeException BuildIndexOutOfRangeException(string parameterName, object actualValue, Exception innerException)
		{
			return BuildArgumentOutOfRangeException(CommonExceptionMessages.ArgumentOutOfRange_IndexOutOfRange, parameterName, actualValue, innerException);
		}


		#endregion

		// (...)
	}
}

Ich verwende statische ExceptionBuilder-Klassen. Es gibt sowohl globale, als auch lokale ExceptionBuilder. Ein globaler ExceptionBuilder ist in meinem Fall immer im Namespace EpiSource.Common.ExceptionBuilders definiert. Ein lokaler ExceptionBuilder ist eine private Unterklasse des Typs, der die generierten Exceptions benötigt. Die notwendigen Strings sind in Ressourcendateien gespeichert. Die für globale ExceptionBuilder in der Datei CommonExceptionMessages.resx, die für lokale ExceptionBuilder gesammelt in der Ressource ExceptionMessages.resx.