What you described here is a textbook example of a strategy pattern. You define an interface for validation, implement as many different implementations as you need, and then instantiate the implementation you need based on what you decide is needed.
 
The following is tested code.

The [Strategy Pattern](https://en.wikipedia.org/wiki/Strategy_pattern) part:

 public interface IValidationStrategy
 {
 bool Validate(string pStringToValidate);
 }

 public class RegexValidator : IValidationStrategy
 {
 private Regex regEx;

 public RegexValidator(Regex regEx)
 {
 this.regEx = regEx;
 }

 public bool Validate(string stringToValidate)
 {
 return regEx.IsMatch(stringToValidate);
 }
 }

 public class WildCardValidator : IValidationStrategy
 {
 private string wildCard;

 public WildCardValidator(string wildCard)
 {
 this.wildCard = wildCard;
 }

 public bool Validate(string pStringToValidate)
 {
 //http://stackoverflow.com/questions/30299671/matching-strings-with-wildcard
 string regex = Regex.Escape(wildCard).Replace("\\*", ".*");
 return Regex.IsMatch(pStringToValidate, "^" + regex + "$");
 }
 }

Accepting a [Dependency Injection](https://en.wikipedia.org/wiki/Dependency_injection) (IValidationStrategy) and using a nested builder class to construct the different implementations in an immutable way:

 public class StringValidator
 {
 private IValidationStrategy validationStrategy;

 //Dependendency Injection constructor
 public StringValidator(IValidationStrategy validationStrategy)
 {
 this.validationStrategy = validationStrategy;
 }

 public bool Validate(string stringToValidate)
 {
 return validationStrategy.Validate(stringToValidate);
 }

 public class Builder
 {
 public StringValidator BuildRegex(string regex)
 {
 return new StringValidator(new RegexValidator(new Regex(regex)));
 }

 public StringValidator BuildWildCard(string wildCard)
 {
 return new StringValidator(new WildCardValidator(wildCard));
 }
 }
 }

Two different ways to test: 

 class Program
 {
 static void Main(string[] args)
 {
 Console.Out.WriteLine(
 "IsValid: {0}",
 new StringValidator.Builder()
 .BuildRegex(@"\d+")
 .Validate("55")
 );

 Console.Out.WriteLine(
 "IsValid: {0}",
 new StringValidator.Builder()
 .BuildWildCard("*")
 .Validate("Whatever string to be validated")
 );

 // Or, if you hate using nameless temporary objects

 StringValidator.Builder stringValidatorBuilder = new StringValidator.Builder();

 string regex = @"\d+";
 StringValidator regValidator = stringValidatorBuilder.BuildRegex(regex);
 bool isValid = regValidator.Validate("55");
 Console.Out.WriteLine("IsValid: {0}", isValid);

 string wildCard = "*";
 StringValidator wildCardValidator = stringValidatorBuilder.BuildWildCard(wildCard);
 isValid = wildCardValidator.Validate("Whatever string to be validated");
 Console.Out.WriteLine("IsValid: {0}", isValid);
 }
 }

Outputs:

 IsValid: True
 IsValid: True
 IsValid: True
 IsValid: True