# ArgumentException

***

**1. Argument is null or empty.**

```csharp
public static void ValidateArgumentNotNullOrEmpty(string argument, string argumentName)
{
    if (string.IsNullOrEmpty(argument))
    {
        throw new ArgumentException($"The argument '{argumentName}' cannot be null or empty.", argumentName);
    }
}
```

**2. Argument is out of range.**

```csharp
public static void ValidateArgumentInRange(int argument, int min, int max, string argumentName)
{
    if (argument < min || argument > max)
    {
        throw new ArgumentException($"The argument '{argumentName}' must be between {min} and {max}.", argumentName);
    }
}
```

**3. Argument is invalid.**

```csharp
public static void ValidateArgumentIsValid(bool isValid, string argumentName)
{
    if (!isValid)
    {
        throw new ArgumentException($"The argument '{argumentName}' is invalid.", argumentName);
    }
}
```

**4. Argument is not of the expected type.**

```csharp
public static void ValidateArgumentIsExpectedType(object argument, Type expectedType, string argumentName)
{
    if (argument.GetType() != expectedType)
    {
        throw new ArgumentException($"The argument '{argumentName}' must be of type {expectedType}.", argumentName);
    }
}
```

**5. Argument is not supported.**

```csharp
public static void ValidateArgumentIsSupported(object argument, IEnumerable<object> supportedValues, string argumentName)
{
    if (!supportedValues.Contains(argument))
    {
        throw new ArgumentException($"The argument '{argumentName}' is not supported.", argumentName);
    }
}
```

**6. Argument is not unique.**

```csharp
public static void ValidateArgumentIsUnique(object argument, IEnumerable<object> existingValues, string argumentName)
{
    if (existingValues.Contains(argument))
    {
        throw new ArgumentException($"The argument '{argumentName}' must be unique.", argumentName);
    }
}
```

**7. Argument is too long.**

```csharp
public static void ValidateArgumentMaxLength(string argument, int maxLength, string argumentName)
{
    if (argument.Length > maxLength)
    {
        throw new ArgumentException($"The argument '{argumentName}' must be less than or equal to {maxLength} characters.", argumentName);
    }
}
```

**8. Argument is too short.**

```csharp
public static void ValidateArgumentMinLength(string argument, int minLength, string argumentName)
{
    if (argument.Length < minLength)
    {
        throw new ArgumentException($"The argument '{argumentName}' must be greater than or equal to {minLength} characters.", argumentName);
    }
}
```

**9. Argument is not a number.**

```csharp
public static void ValidateArgumentIsNumber(string argument, string argumentName)
{
    if (!int.TryParse(argument, out _))
    {
        throw new ArgumentException($"The argument '{argumentName}' must be a number.", argumentName);
    }
}
```

**10. Argument is not a valid email address.**

```csharp
public static void ValidateArgumentIsEmail(string argument, string argumentName)
{
    if (!Regex.IsMatch(argument, @"^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$"))
    {
        throw new ArgumentException($"The argument '{argumentName}' must be a valid email address.", argumentName);
    }
}
```

**11. Argument is not a valid date.**

```csharp
public static void ValidateArgumentIsDate(string argument, string argumentName)
{
    if (!DateTime.TryParse(argument, out _))
    {
        throw new ArgumentException($"The argument '{argumentName}' must be a valid date.", argumentName);
    }
}
```

**12. Argument is not a valid time.**

```csharp
public static void ValidateArgumentIsTime(string argument, string argumentName)
{
    if (!TimeSpan.TryParse(argument, out _))
    {
        throw new ArgumentException($"The argument '{argumentName}' must be a valid time.", argumentName);
    }
}
```

**13. Argument is not a valid GUID.**

```csharp
public static void ValidateArgumentIsGuid(string argument, string argumentName)
{
    if (!Guid.TryParse(argument, out _))
    {
        throw new ArgumentException($"The argument '{argumentName}' must be a valid GUID.", argumentName);
    }
}
```

**14. Argument is not a valid URL.**

```csharp
public static void ValidateArgumentIsUrl(string argument, string argumentName)
{
    if (!Uri.TryCreate(argument, UriKind.Absolute, out _))
    {
        throw new ArgumentException($"The argument '{argumentName}' must be a valid URL.", argumentName);
    }
}
```

**15. Argument is not a valid file path.**

```csharp
public static void ValidateArgumentIsFilePath(string argument, string argumentName)
{
    if (!File.Exists(argument))
    {
        throw new ArgumentException($"The argument '{argumentName}' must be a valid file path.", argumentName);
    }
}
```

**16. Argument is not a valid directory path.**

```csharp
public static void ValidateArgumentIsDirectoryPath(string argument, string argumentName)
{
    if (!Directory.Exists(argument))
    {
        throw new ArgumentException($"The argument '{argumentName}' must be a valid directory path.", argumentName);
    }
}
```

**17. Argument is not a valid file name.**

```csharp
public static void ValidateArgumentIsFileName(string argument, string argumentName)
{
    if (!Path.GetFileNameWithoutExtension(argument).IsValidFileName())
    {
        throw new ArgumentException($"The argument '{argumentName}' must be a valid file name.", argumentName);
    }
}
```

**18. Argument is not a valid directory name.**

```csharp
public static void ValidateArgumentIsDirectoryName(string argument, string argumentName)
{
    if (!Path.GetDirectoryName(argument).IsValidDirectoryName())
    {
        throw new ArgumentException($"The argument '{argumentName}' must be a valid directory name.", argumentName);
    }
}
```

**19. Argument is not a valid file extension.**

```csharp
public static void ValidateArgumentIsFileExtension(string argument, string argumentName)
{
    if (!Path.GetExtension(argument).IsValidFileExtension())
    {
        throw new ArgumentException($"The argument '{argumentName}' must be a valid file extension.", argumentName);
    }
}
```

**20. Argument is not a valid path.**

```csharp
public static void ValidateArgumentIsPath(string argument, string argumentName)
{
    if (!Path.IsPathRooted(argument))
    {
        throw new ArgumentException($"The argument '{argumentName}' must be a valid path.", argumentName);
    }
}
```

**21. Argument is not a valid color.**

```csharp
public static void ValidateArgumentIsColor(string argument, string argumentName)
{
    if (!Color.TryParse(argument, out _))
    {
        throw new ArgumentException($"The argument '{argumentName}' must be a valid color.", argumentName);
    }
}
```

**22. Argument is not a valid font.**

```csharp
public static void ValidateArgumentIsFont(string argument, string argumentName)
{

```