ConfigurationValidatorAttribute Sınıf

Tanım

Ad Alanı:

System.Configuration

Bütünleştirilmiş Kod:

System.Configuration.ConfigurationManager.dll

Paket:

System.Configuration.ConfigurationManager v8.0.0

Kaynak:

ConfigurationValidatorAttribute.cs

Doğrulayıcı öznitelik türleri için System.Configuration temel sınıf görevi görür.

C#

[System.AttributeUsage(System.AttributeTargets.Property)]
public class ConfigurationValidatorAttribute : Attribute

Devralma

Object

Attribute

ConfigurationValidatorAttribute

Türetilmiş

System.Configuration.CallbackValidatorAttribute

System.Configuration.IntegerValidatorAttribute

System.Configuration.LongValidatorAttribute

System.Configuration.PositiveTimeSpanValidatorAttribute

System.Configuration.RegexStringValidatorAttribute

System.Configuration.StringValidatorAttribute

System.Configuration.SubclassTypeValidatorAttribute

System.Configuration.TimeSpanValidatorAttribute

Öznitelikler

AttributeUsageAttribute

Örnekler

Aşağıdaki kod örnekleri, türünü kullanarak ConfigurationValidatorAttribute iki özel doğrulayıcının nasıl oluşturulacağını gösterir. İlk örnek, sabit kodlanmış parametreleri kullanarak doğrulama gerçekleştirir; İkinci örnek, ilgili bölüm özelliğine uygulandığı sırada kendisine atanan parametreleri kullanarak doğrulama gerçekleştirir. Bu kod örneği ayrıca üç destekleyici dosya içerir. İlk dosya, yukarıda açıklanan doğrulayıcıları kullanan özel bölümü, ikinci dosya özel bir dönüştürücü türü içerir ve üçüncü dosya özel doğrulayıcıları oluşturan ve kullanan konsol uygulamasını ve bunları içeren bölümü içerir.

Aşağıdaki kod örneği, sabit kodlanmış parametrelerle sabit bir doğrulayıcının nasıl oluşturulacağını gösterir.

C#

using System;
using System.Collections.Generic;
using System.Collections;
using System.Text;
using System.Configuration;

namespace Samples.AspNet
{
    // Show how to create a custom fixed 
    // validator. That is a validator whose
    // validation parameters are hard code in this
    // type.
    public class FixedValidator :
            ConfigurationValidatorBase
    {
       
        public override bool CanValidate(Type type)
        {
            return type == typeof(Automobile);
        }

        public override void Validate(object value)
        {

            ArrayList make = new ArrayList();

            make.Add("Ferrari");
            make.Add("Porsche");
            make.Add("Lamborghini");

            int minYear = 2004;
            long maxMiles = 100;
            string color = "red";
            
            Automobile car = (Automobile)value;

            try
            {
                if (!make.Contains(car.Make))
                {
                    throw new ConfigurationErrorsException(
                       "My dream car is not made by " + car.Make);
                }

                // Make sure the year is valid 
                if (car.Year < minYear)
                {

                    throw new ConfigurationErrorsException(
                       "My dream car cannot be older than " + minYear.ToString());
                }

                // Make sure the car can still run on its own
                if (car.Miles > maxMiles)
                {
                  throw new ConfigurationErrorsException(
                        "My dream car drive odometer cannot read more than " + 
                        maxMiles.ToString() + " miles");
                }

                // Validate color
                if (car.Color.ToLower() != color)
                {
                    throw new ConfigurationErrorsException(
                        "My dream car can oly be " + color);
                }
            }
            catch (ConfigurationErrorsException err)
            {
                Console.WriteLine(err.ToString());
            }
        }
    }
  }

Aşağıdaki kod örneği, programlanabilir bir doğrulayıcının nasıl oluşturulacağını gösterir.

C#

using System;
using System.Collections.Generic;
using System.Text;
using System.Configuration;

namespace Samples.AspNet
{

    // Show how to create a custom programmable 
    // validator. That is a validator whose
    // validation parameters can be passed when the
    // validator is applied to a property.
    public class ProgrammableValidator : 
        ConfigurationValidatorBase
    {
        private string pmake;
        private string pcolor;
        private long pmaxMiles;
        private int pminYear;

        public ProgrammableValidator(string make, string color, 
            long maxMiles, int minYear)
        {
            pmake = make;
            pcolor = color;
            pminYear = minYear;
            pmaxMiles = maxMiles;
        }

        public override bool CanValidate(Type type)
        {
            return type == typeof(Automobile);
        }

        public override void Validate(object value)
        {

            Automobile car = (Automobile)value;

            try
            {

                // Validate make
                if (car.Make != pmake)
                {
                    throw new ConfigurationErrorsException(
                       "I do not by cars made by " + car.Make);
                }

                // Validate color
                if (car.Color != pcolor)
                {
                    throw new ConfigurationErrorsException(
                        "My commute car must be " + pcolor);
                }

                // Validate year
                if (car.Year < pminYear)
                {
                    throw new ConfigurationErrorsException(
                        "It's about time you get a new car.");
                }

                // Validate miles
                if (car.Miles > pmaxMiles)
                {
                    throw new ConfigurationErrorsException(
                        "Don't take too long trips with that car.");
                }
            }
            catch (ConfigurationErrorsException err)
            {
                Console.WriteLine(err.ToString());
            }
        }
    }

    public class ProgrammableValidatorAttribute : 
        ConfigurationValidatorAttribute
    {
        private string pmake;
        private string pcolor;
        private int pminYear;
        private long pmaxMiles;

        public string Make
        {
            get { return pmake; }
            set { pmake = value; }
        }

        public string Color
        {
            get { return pcolor; }
            set { pcolor = value; }
        }

        public int MinYear
        {
            get { return pminYear; }
            set { pminYear = value; }
        }
        public long MaxMiles
        {
            get { return pmaxMiles; }
            set { pmaxMiles = value; }
        }

        public ProgrammableValidatorAttribute(string make, string color,
            long miles, int year)
        {
            pmake = make;
            pcolor = color;
            pminYear = year;
            pmaxMiles = miles;
        }

        public override ConfigurationValidatorBase ValidatorInstance
        {
            get
            {
                return new ProgrammableValidator(pmake, pcolor, pmaxMiles, pminYear);
            }
        }
    }
}

Aşağıdaki kod örneği, önceki doğrulayıcıları kullanarak özel bir bölümün nasıl oluşturulacağını gösterir.

C#

using System;
using System.Collections.Generic;
using System.Text;
using System.Configuration;
using System.ComponentModel;
using System.Globalization;

namespace Samples.AspNet
{
    // Define the distinctive 
    // charecteristics of a car.
    public sealed class Automobile
    {
        public enum specification
        {
            make=0, color=1, miles=2, year=3, picture=4
        };

        public string Make;
        public string Color;
        public int Year;
        public long Miles;
        public string Picture;
    }

    // Define a custom section to select a car.
    // This section contains two properties one
    // to define a commute car the other 
    // to define a dream car.
    // This generates a configuration section such as:
    // <Cars commute="Make:AlfaRomeo Color:Blue Miles:10000 Year:2002"
    // dream="Make:Ferrari Color:Red Miles:10 Year:2005" />
    public sealed class SelectCar :
        ConfigurationSection
    {
        // Define your commute car.
        // The ProgrammableValidatorAttribute allows you to define the 
        // chracteristics of your commute car by changing
        // the values you pass to the next.
        // See the ProgrammableValidatorAttribute for details.
        [ProgrammableValidator("AlfaRomeo", "Blue", 10000, 2002)]
        
        // The AutomobileConverter converts between the Automobile
        // object and its related configuration commute attribute 
        // string value. 
        // Refer to AutomobileConverter for details.
        [TypeConverter(typeof(AutomobileConverter))]
        
        // Define the name of the configuration attribute to associate
        // with this property. Enter the default values.
        // Remember these default values must reflect the parameters
        // you entered in the ProgrammableValidator above.
        [ConfigurationProperty("commute", DefaultValue = "Make:AlfaRomeo Color:Blue Miles:10000 Year:2002")]
        public Automobile Commute
        {
            get
            {
                return (Automobile)this["commute"];
            }
            set
            {
                this["commute"] = value;
            }
        }

        // Apply the FixedValidatorAttribute. Here your choice 
        // (dream) is predetermined by the values contained in the
        // FixedValidatorAttribute. Being a dream, you would think 
        // otherwise but that's not the case.
        // See the FixedValidatorAttribute to choose your dream.
         [ConfigurationValidatorAttribute(
          typeof(FixedValidator))]

        // The AutomobileConverter converts between the Automobile
        // object and its related configuration dream attribute 
        // string value. 
        // Refer to AutomobileConverter for details.
        [TypeConverter(typeof(AutomobileConverter))]
        
        [ConfigurationProperty("dream", DefaultValue = "Make:Ferrari Color:Red Miles:10 Year:2005")]
        public Automobile Dream
        {
            get
            {
                return (Automobile)this["dream"];
            }
            set
            {
                this["dream"] = value;
            }
        }

        public SelectCar()
        {
            // Here you put your 
            // initializations, if necessary.
        }
    }    
}

Aşağıdaki kod örneğinde özel dönüştürücü oluşturma gösterilmektedir.

C#

using System;
using System.Collections.Generic;
using System.Text;
using System.Configuration;
using System.ComponentModel;
using System.Globalization;

namespace Samples.AspNet
{
    // The AutomobileConverter converts between the Automobile
    // object and its related configuration commute and
    // dream attribute string values. 
    public sealed class AutomobileConverter :
    ConfigurationConverterBase
    {
       
        internal bool ValidateType(object value,
            Type expected)
        {
            bool result;

            if ((value != null) &&
                (value.GetType() != expected))
                result = false;
            else
                result = true;

            return result;
        }

        public override bool CanConvertTo(
            ITypeDescriptorContext ctx, Type type)
        {
            return (type == typeof(Automobile));
        }

        public override bool CanConvertFrom(
            ITypeDescriptorContext ctx, Type type)
        {
            return (type == typeof(Automobile));
        }

        public override object ConvertTo(
            ITypeDescriptorContext ctx, CultureInfo ci,
            object value, Type type)
        {
            string data;

            if (ValidateType(value, typeof(Automobile)))
            {
                string make = (string)(((Automobile)value).Make);
                string color = (string)(((Automobile)value).Color);
                string miles = (string)(((Automobile)value).Miles.ToString());
                string year = (string)(((Automobile)value).Year.ToString());

                data = "Make:" + make + " Color:" + color + 
                        " Miles:" + miles + " Year:" + year;
            }
            else
            {
                data = "Invalid type";
            }

            return data;
        }

        public override object ConvertFrom(
            ITypeDescriptorContext ctx, CultureInfo ci, object data)
        {
            Automobile selectedCar = 
                new Automobile();
 
            string carInfo  = (string)data;

            string[] carSpecs = carInfo.Split(new Char[] { ' ' });

            // selectedCar.Make = carSpecs[0].ToString();
            // selectedCar.Make = carSpecs[0].ToString();

            string make = 
                carSpecs[(int)Automobile.specification.make].ToString();
            string color =
                carSpecs[(int)Automobile.specification.color].ToString();
            string miles =
                carSpecs[(int)Automobile.specification.miles].ToString();
            string year =
                carSpecs[(int)Automobile.specification.year].ToString();

            selectedCar.Make = 
                make.Substring(make.IndexOf(":")+1);
            selectedCar.Color = 
                color.Substring(color.IndexOf(":") + 1);
            selectedCar.Miles = 
                Convert.ToInt32(miles.Substring(miles.IndexOf(":") + 1));
            selectedCar.Year = 
                Convert.ToInt32(year.Substring(year.IndexOf(":") + 1));
            
            return selectedCar;
        }
    }
}

Aşağıdaki kod örneği, özel doğrulayıcıları ve bunların içeren bölümünü derleyen ve kullanan konsol uygulamasının nasıl oluşturulacağını gösterir.

C#

using System;
using System.Collections.Generic;
using System.Text;
using System.Configuration;

namespace Samples.AspNet
{

    class TestingConfigValidatorAttribute
    {
        static TestingConfigValidatorAttribute()
        {
            try
            {

                SelectCar car;

                // Get the current configuration file.
                System.Configuration.Configuration config =
                    ConfigurationManager.OpenExeConfiguration(
                    ConfigurationUserLevel.None);

                // Create the section entry for the selected car.
                if (config.Sections["Cars"] == null)
                {
                    
                    car = new SelectCar();
                    
                    config.Sections.Add("Cars", car);
                    
                    car.SectionInformation.ForceSave = true;
                    config.Save(ConfigurationSaveMode.Full);
                }
            }
            catch (ConfigurationErrorsException err)
            {
                Console.WriteLine(err.ToString());
            }
        }

        private static void GetCars()
        {

            try
            {
                // Get the current configuration file.
                System.Configuration.Configuration config =
                    ConfigurationManager.OpenExeConfiguration(
                    ConfigurationUserLevel.None);

                // Get the Cars section.
                SelectCar cars =
                    config.GetSection("Cars") as SelectCar;

                Console.WriteLine("Dream Make: {0} Color: {1} Miles: {2} Year: {3}",
                    cars.Dream.Make, cars.Dream.Color,
                    cars.Dream.Miles, cars.Dream.Year);

                Console.WriteLine("Commute Make: {0} Color: {1} Miles: {2} Year: {3}",
                    cars.Commute.Make, cars.Commute.Color,
                    cars.Commute.Miles, cars.Commute.Year);
            }
            catch (ConfigurationErrorsException err)
            {
                Console.WriteLine(err.ToString());
            }
        }

        private static void NotAllowedCars()
        {

            try
            {
                // Get the current configuration file.
                System.Configuration.Configuration config =
                    ConfigurationManager.OpenExeConfiguration(
                    ConfigurationUserLevel.None);

                Automobile dreamCar = new Automobile();
                dreamCar.Color = "Red";
                dreamCar.Make = "BMW";
                dreamCar.Miles = 10;
                dreamCar.Year = 2005;

                Automobile commuteCar = new Automobile();
                commuteCar.Color = "Blue";
                commuteCar.Make = "Yugo";
                commuteCar.Miles = 10;
                commuteCar.Year = 1990;

                // Get the Cars section.
                SelectCar cars =
                    config.GetSection("Cars") as SelectCar;

                cars.Dream = dreamCar;
                cars.Commute = commuteCar;
            }
            catch (ConfigurationErrorsException err)
            {
                Console.WriteLine(err.ToString());
            }
        }

        static void Main(string[] args)
        {
            GetCars();
            NotAllowedCars();
        }
    }
}

Aşağıdaki kod örneği, önceki örnek tarafından kullanılan bir yapılandırma alıntısıdır.

XML

<?xml version="1.0" encoding="utf-8"?>  
<configuration>  
    <configSections>  
        <section name="Cars" type="Samples.AspNet.SelectCar, ConfigValidatorAttribute, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" allowLocation="false" allowDefinition="Everywhere" allowExeDefinition="MachineToApplication" restartOnExternalChanges="true" requirePermission="true" />  
    </configSections>  
    <Cars commute="Make:AlfaRomeo Color:Blue Miles:10000 Year:2002"  
        dream="Make:Ferrari Color:Red Miles:10 Year:2005" />  
</configuration>  

Açıklamalar

Tüm ASP.NET yapılandırma standardı doğrulayıcı öznitelik türleri'nden ConfigurationValidatorAttributetüretilir. Kendi özel doğrulayıcı özniteliğinizi oluşturmak için bu türü kullanabilirsiniz.

Oluşturucular

ConfigurationValidatorAttribute()	ConfigurationValidatorAttribute sınıfının yeni bir örneğini başlatır.
ConfigurationValidatorAttribute(Type)	Belirtilen doğrulayıcı türünü kullanarak sınıfının yeni bir örneğini ConfigurationValidatorAttribute başlatır.

Özellikler

TypeId	Türetilmiş bir sınıfta uygulandığında, bu Attributeiçin benzersiz bir tanımlayıcı alır. (Devralındığı yer: Attribute)
ValidatorInstance	Doğrulayıcı öznitelik örneğini alır.
ValidatorType	Doğrulayıcı özniteliğinin türünü alır.

Yöntemler

Equals(Object)	Bu örneğin belirtilen bir nesneye eşit olup olmadığını gösteren bir değeri döndürür. (Devralındığı yer: Attribute)
GetHashCode()	Bu örneğe ilişkin karma kodu döndürür. (Devralındığı yer: Attribute)
GetType()	Type Geçerli örneğini alır. (Devralındığı yer: Object)
IsDefaultAttribute()	Türetilmiş bir sınıfta geçersiz kılındığında, bu örneğin değerinin türetilmiş sınıf için varsayılan değer olup olmadığını gösterir. (Devralındığı yer: Attribute)
Match(Object)	Türetilmiş bir sınıfta geçersiz kılındığında, bu örneğin belirtilen bir nesneye eşit olup olmadığını gösteren bir değer döndürür. (Devralındığı yer: Attribute)
MemberwiseClone()	Geçerli Objectöğesinin sığ bir kopyasını oluşturur. (Devralındığı yer: Object)
ToString()	Geçerli nesneyi temsil eden dizeyi döndürür. (Devralındığı yer: Object)

Şunlara uygulanır

Ayrıca bkz.

• IntegerValidatorAttribute
• TimeSpanValidatorAttribute
• StringValidatorAttribute