Komuta

Örneğe göz atın

Model-View-ViewModel (MVVM) desenini kullanan bir .NET Çok Platformlu Uygulama Kullanıcı Arabirimi (.NET MAUI) uygulamasında, veri bağlamaları görünüm modelindeki özellikler arasında tanımlanır ve bu genellikle görünümdeki özelliklerinden türetilen INotifyPropertyChangedbir sınıftır ve genellikle XAML dosyasıdır. Bazen bir uygulamanın, kullanıcının görünüm modelinde bir şeyi etkileyen komutları başlatmasını gerektirerek bu özellik bağlamalarının ötesine geçme ihtiyacı vardır. Bu komutlar genellikle düğme tıklamaları veya parmak dokunuşları ile işaretlenir ve geleneksel olarak bir veya olayının işleyicisindeki Clicked Button Tapped TapGestureRecognizerarka planda kod dosyasında işlenir.

Komut arabirimi, MVVM mimarisine çok daha uygun komutları uygulamak için alternatif bir yaklaşım sağlar. Görünüm modeli, görünümde tıklama gibi Button belirli bir etkinliğe tepki olarak yürütülen yöntemler olan komutları içerebilir. Veri bağlamaları bu komutlarla Buttonarasında tanımlanır.

ile görünüm modeli arasında Button veri bağlamaya izin vermek için iki Button özelliği tanımlar:

• Command türü System.Windows.Input.ICommand
• CommandParameter türü Object

Komut arabirimini kullanmak için, kaynağın türünde ICommandgörünüm modelinde bir özellik Button olduğu özelliğini hedefleyen Command bir veri bağlaması tanımlarsınız. Görünüm modeli, düğmeye tıklandığında yürütülen bu ICommand özellik ile ilişkilendirilmiş kodu içerir. Hepsi görünüm modelinde CommandParameter aynı ICommand özelliğe bağlıysa, birden çok düğmeyi ayırt etmek için özelliğini rastgele verilere ayarlayabilirsiniz.

Diğer birçok görünüm ve CommandParameter özelliklerini de tanımlarCommand. Bu komutların tümü görünümdeki kullanıcı arabirimi nesnesine bağımlı olmayan bir yaklaşım kullanılarak bir görünüm modelinde işlenebilir.

ICommands

ICommand Arabirimi System.Windows.Input ad alanında tanımlanır ve iki yöntemden ve bir olaydan oluşur:

public interface ICommand
{
    public void Execute (Object parameter);
    public bool CanExecute (Object parameter);
    public event EventHandler CanExecuteChanged;
}

Komut arabirimini kullanmak için görünüm modelinizin türünde ICommandözellikler içermesi gerekir:

public ICommand MyCommand { private set; get; }

Görünüm modeli, arabirimini uygulayan bir sınıfa ICommand da başvurmalıdır. Görünümde, öğesinin Command Button özelliği bu özelliğe bağlıdır:

<Button Text="Execute command"
        Command="{Binding MyCommand}" />

Kullanıcı tuşuna bastığındaButtonButton, özelliğine Command bağlı nesnede ICommand yöntemini çağırırExecute.

Bağlama özelliğinde Command Buttonilk kez tanımlandığında ve veri bağlaması bir şekilde değiştiğinde, Button nesnesindeki CanExecute ICommand yöntemini çağırır. döndürürse CanExecute false, Button kendisini devre dışı bırakır. Bu, belirli bir komutun şu anda kullanılamadığını veya geçersiz olduğunu gösterir.

ayrıca Button olayına CanExecuteChanged ICommandbir işleyici ekler. Olay görünüm modeli içinden oluşturulur. Bu olay tetiklendiğinde, yeniden çağrılar Button CanExecute . döndürürse Button CanExecute true kendisini etkinleştirir ve döndürürse CanExecute falsekendisini devre dışı bırakır.

Görünüm modeliniz türünde ICommandbir özellik tanımladığında, görünüm modeli arabirimini uygulayan ICommand bir sınıfı da içermelidir veya bunlara başvurmalıdır. Bu sınıfın ve CanExecute yöntemlerini içermesi Execute veya bunlara başvurması ve yöntemin CanExecuteChanged farklı bir değer döndürebileceği her durumda CanExecute olayı tetiklemesi gerekir. Arabirimi uygulamak için .NET MAUI'de bulunan veya Command<T> sınıfını ICommand kullanabilirsinizCommand. Bu sınıflar, sınıf oluşturucularında ve CanExecute yöntemlerinin Execute gövdelerini belirtmenize olanak sağlar.

Temel komut

Aşağıdaki örneklerde bir görünüm modelinde uygulanan temel komutlar gösterilmektedir.

PersonViewModel sınıfı, bir kişiyi tanımlayan , Ageve Skills adlı Nameüç özelliği tanımlar:

public class PersonViewModel : INotifyPropertyChanged
{
    string name;
    double age;
    string skills;

    public event PropertyChangedEventHandler PropertyChanged;

    public string Name
    {
        set { SetProperty(ref name, value); }
        get { return name; }
    }

    public double Age
    {
        set { SetProperty(ref age, value); }
        get { return age; }
    }

    public string Skills
    {
        set { SetProperty(ref skills, value); }
        get { return skills; }
    }

    public override string ToString()
    {
        return Name + ", age " + Age;
    }

    bool SetProperty<T>(ref T storage, T value, [CallerMemberName] string propertyName = null)
    {
        if (Object.Equals(storage, value))
            return false;

        storage = value;
        OnPropertyChanged(propertyName);
        return true;
    }

    protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

PersonCollectionViewModel Aşağıda gösterilen sınıf, türünde PersonViewModel yeni nesneler oluşturur ve kullanıcının verileri doldurmasına izin verir. Bu amaçla, sınıfı , ve türünde bool, özellikleri türünde PersonViewModelöğesini tanımlarIsEditing.PersonEdit Buna ek olarak, sınıfı türün üç özelliğini ve türünde ICommand IList<PersonViewModel>adlı Persons bir özelliği tanımlar:

public class PersonCollectionViewModel : INotifyPropertyChanged
{
    PersonViewModel personEdit;
    bool isEditing;

    public event PropertyChangedEventHandler PropertyChanged;
    ···

    public bool IsEditing
    {
        private set { SetProperty(ref isEditing, value); }
        get { return isEditing; }
    }

    public PersonViewModel PersonEdit
    {
        set { SetProperty(ref personEdit, value); }
        get { return personEdit; }
    }

    public ICommand NewCommand { private set; get; }
    public ICommand SubmitCommand { private set; get; }
    public ICommand CancelCommand { private set; get; }

    public IList<PersonViewModel> Persons { get; } = new ObservableCollection<PersonViewModel>();

    bool SetProperty<T>(ref T storage, T value, [CallerMemberName] string propertyName = null)
    {
        if (Object.Equals(storage, value))
            return false;

        storage = value;
        OnPropertyChanged(propertyName);
        return true;
    }

    protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

Bu örnekte, üç ICommand özellikte yapılan değişiklikler ve Persons özelliği olaylara neden PropertyChanged olmaz. Bu özelliklerin tümü, sınıf ilk oluşturulduğunda ayarlanır ve değişmez.

Aşağıdaki örnekte, kullanan XAML gösterilmektedir PersonCollectionViewModel:

<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             xmlns:local="clr-namespace:DataBindingDemos"
             x:Class="DataBindingDemos.PersonEntryPage"
             Title="Person Entry"
             x:DataType="local:PersonCollectionViewModel">             
    <ContentPage.BindingContext>
        <local:PersonCollectionViewModel />
    </ContentPage.BindingContext>
    <Grid Margin="10">
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto" />
            <RowDefinition Height="Auto" />
            <RowDefinition Height="Auto" />
            <RowDefinition Height="*" />
        </Grid.RowDefinitions>

        <!-- New Button -->
        <Button Text="New"
                Grid.Row="0"
                Command="{Binding NewCommand}"
                HorizontalOptions="Start" />

        <!-- Entry Form -->
        <Grid Grid.Row="1"
              IsEnabled="{Binding IsEditing}">
            <Grid x:DataType="local:PersonViewModel"
                  BindingContext="{Binding PersonEdit}">
                <Grid.RowDefinitions>
                    <RowDefinition Height="Auto" />
                    <RowDefinition Height="Auto" />
                    <RowDefinition Height="Auto" />
                </Grid.RowDefinitions>
                <Grid.ColumnDefinitions>
                    <ColumnDefinition Width="Auto" />
                    <ColumnDefinition Width="*" />
                </Grid.ColumnDefinitions>

                <Label Text="Name: " Grid.Row="0" Grid.Column="0" />
                <Entry Text="{Binding Name}"
                       Grid.Row="0" Grid.Column="1" />
                <Label Text="Age: " Grid.Row="1" Grid.Column="0" />
                <StackLayout Orientation="Horizontal"
                             Grid.Row="1" Grid.Column="1">
                    <Stepper Value="{Binding Age}"
                             Maximum="100" />
                    <Label Text="{Binding Age, StringFormat='{0} years old'}"
                           VerticalOptions="Center" />
                </StackLayout>
                <Label Text="Skills: " Grid.Row="2" Grid.Column="0" />
                <Entry Text="{Binding Skills}"
                       Grid.Row="2" Grid.Column="1" />
            </Grid>
        </Grid>

        <!-- Submit and Cancel Buttons -->
        <Grid Grid.Row="2">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="*" />
                <ColumnDefinition Width="*" />
            </Grid.ColumnDefinitions>

            <Button Text="Submit"
                    Grid.Column="0"
                    Command="{Binding SubmitCommand}"
                    VerticalOptions="Center" />
            <Button Text="Cancel"
                    Grid.Column="1"
                    Command="{Binding CancelCommand}"
                    VerticalOptions="Center" />
        </Grid>

        <!-- List of Persons -->
        <ListView Grid.Row="3"
                  ItemsSource="{Binding Persons}" />
    </Grid>
</ContentPage>

Bu örnekte, sayfanın BindingContext özelliği olarak PersonCollectionViewModelayarlanır. , Grid özelliği görünüm modelinde özelliğine bağlı olan Command Yeni metnini, özelliğine NewCommand bağlı özelliklere IsEditing sahip bir giriş formunun yanı sıra , ve görünümmodelinin PersonViewModelözelliklerine SubmitCommand CancelCommand bağlı iki düğme daha içerirButton. , ListView önceden girilmiş kişilerin koleksiyonunu görüntüler:

Aşağıdaki ekran görüntüsünde , bir yaş ayarlandıktan sonra etkinleştirilen Gönder düğmesi gösterilmektedir:

Kullanıcı Yeni düğmesine ilk kez bastığında, bu giriş formunu etkinleştirir ancak Yeni düğmesini devre dışı bırakır. Kullanıcı daha sonra bir ad, yaş ve beceri girer. Düzenleme sırasında kullanıcı, baştan başlamak için İptal düğmesine basabilir. Yalnızca bir ad ve geçerli bir yaş girildiğinde Gönder düğmesi etkinleştirilir. Bu Gönder düğmesine basıldığında, kişi tarafından görüntülenen koleksiyona ListViewaktarılır. İptal veya Gönder düğmesine basıldıktan sonra, giriş formu temizlenir ve Yeni düğmesi yeniden etkinleştirilir.

Yeni, Gönder ve İptal düğmelerinin tüm mantığı , SubmitCommandve CancelCommand özelliklerinin tanımları NewCommandaracılığıyla işlenirPersonCollectionViewModel. oluşturucu bu PersonCollectionViewModel üç özelliği türündeki Commandnesnelere ayarlar.

sınıfının oluşturucusunun Command türü ve Func<bool> ve CanExecute yöntemlerine Execute karşılık gelen bağımsız değişkenleri Action geçirmenize olanak tanır. Bu eylem ve işlev oluşturucuda Command lambda işlevleri olarak tanımlanabilir:

public class PersonCollectionViewModel : INotifyPropertyChanged
{
    ···
    public PersonCollectionViewModel()
    {
        NewCommand = new Command(
            execute: () =>
            {
                PersonEdit = new PersonViewModel();
                PersonEdit.PropertyChanged += OnPersonEditPropertyChanged;
                IsEditing = true;
                RefreshCanExecutes();
            },
            canExecute: () =>
            {
                return !IsEditing;
            });
        ···
    }

    void OnPersonEditPropertyChanged(object sender, PropertyChangedEventArgs args)
    {
        (SubmitCommand as Command).ChangeCanExecute();
    }

    void RefreshCanExecutes()
    {
        (NewCommand as Command).ChangeCanExecute();
        (SubmitCommand as Command).ChangeCanExecute();
        (CancelCommand as Command).ChangeCanExecute();
    }
    ···
}

Kullanıcı Yeni düğmesine tıkladığında, execute oluşturucuya Command geçirilen işlev yürütülür. Bu, yeni PersonViewModel bir nesne oluşturur, nesnenin PropertyChanged olayı üzerinde bir işleyici ayarlar, olarak trueayarlar IsEditing ve oluşturucudan sonra tanımlanan yöntemi çağırırRefreshCanExecutes.

sınıfı, Command arabirimini ICommand uygulamanın yanı sıra adlı ChangeCanExecutebir yöntem de tanımlar. Bir viewmodel, yöntemin dönüş değerini CanExecute değiştirebilecek herhangi bir şey olduğunda bir ICommand özelliği çağırmalıdırChangeCanExecute. çağrısıChangeCanExecute, sınıfının yöntemini tetiklesine CanExecuteChanged neden olurCommand. Button, bu olay için bir işleyici eklemiş ve yeniden çağırarak CanExecute ve ardından bu yöntemin dönüş değerine göre kendisini etkinleştirerek yanıt verir.

yöntemi çağırdığındaRefreshCanExecutes, NewCommand özelliği öğesine ChangeCanExecutebir çağrı alır ve Button yöntemi çağırdığındacanExecute, artık özelliği şu anda trueolduğu için IsEditing yöntemini döndürürfalse.NewCommand execute

PropertyChanged Yeni PersonViewModel nesnenin işleyicisi yöntemini SubmitCommandçağırırChangeCanExecute:

public class PersonCollectionViewModel : INotifyPropertyChanged
{
    ···
    public PersonCollectionViewModel()
    {
        ···
        SubmitCommand = new Command(
            execute: () =>
            {
                Persons.Add(PersonEdit);
                PersonEdit.PropertyChanged -= OnPersonEditPropertyChanged;
                PersonEdit = null;
                IsEditing = false;
                RefreshCanExecutes();
            },
            canExecute: () =>
            {
                return PersonEdit != null &&
                       PersonEdit.Name != null &&
                       PersonEdit.Name.Length > 1 &&
                       PersonEdit.Age > 0;
            });
        ···
    }
    ···
}

canExecute için işleviSubmitCommand, düzenlenmekte olan nesnede her özellik değiştiğinde PersonViewModel çağrılır. Yalnızca özelliği en az bir karakter uzunluğunda ve Age 0'dan büyük olduğunda Name döndürürtrue. Bu sırada Gönder düğmesi etkinleştirilir.

execute Submit işlevi, özelliği değiştirilmiş işleyicisini öğesinden PersonViewModelkaldırır, nesnesini koleksiyona Persons ekler ve her şeyi ilk durumuna döndürür.

İptal düğmesinin işlevi, nesneyi koleksiyona eklemek dışında Gönder düğmesinin yaptığı her şeyi yapar: execute

public class PersonCollectionViewModel : INotifyPropertyChanged
{
    ···
    public PersonCollectionViewModel()
    {
        ···
        CancelCommand = new Command(
            execute: () =>
            {
                PersonEdit.PropertyChanged -= OnPersonEditPropertyChanged;
                PersonEdit = null;
                IsEditing = false;
                RefreshCanExecutes();
            },
            canExecute: () =>
            {
                return IsEditing;
            });
    }
    ···
}

yöntemicanExecute, düzenlenmekte olan herhangi bir PersonViewModel zamanda döndürürtrue.

Komut parametrelerini kullanma

Bazen görünüm modelinde aynı ICommand özelliği paylaşmak bir veya daha fazla düğme veya diğer kullanıcı arabirimi nesneleri için kullanışlıdır. Bu durumda, düğmelerini CommandParameter ayırt etmek için özelliğini kullanabilirsiniz.

Bu paylaşılan ICommand özellikler için sınıfını Command kullanmaya devam edebilirsiniz. sınıfı, türündeki Objectparametrelere sahip ve canExecute yöntemlerini kabul execute eden alternatif bir oluşturucu tanımlar. bu yöntemlere bu şekilde CommandParameter geçirilir. Ancak, bir CommandParameterbelirtirken, olarak ayarlanan CommandParameternesnenin türünü belirtmek için genel Command<T> sınıfı kullanmak en kolayıdır. execute Belirttiğiniz ve canExecute yöntemleri bu tür parametrelere sahiptir.

Aşağıdaki örnekte ondalık sayı girmek için bir klavye gösterilmektedir:

<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             xmlns:local="clr-namespace:DataBindingDemos"
             x:Class="DataBindingDemos.DecimalKeypadPage"
             Title="Decimal Keyboard"
             x:DataType="local:DecimalKeypadViewModel">
    <ContentPage.BindingContext>
        <local:DecimalKeypadViewModel />
    </ContentPage.BindingContext>
    <ContentPage.Resources>
        <Style TargetType="Button">
            <Setter Property="FontSize" Value="32" />
            <Setter Property="BorderWidth" Value="1" />
            <Setter Property="BorderColor" Value="Black" />
        </Style>
    </ContentPage.Resources>

    <Grid WidthRequest="240"
          HeightRequest="480"
          ColumnDefinitions="80, 80, 80"
          RowDefinitions="Auto, Auto, Auto, Auto, Auto, Auto"
          ColumnSpacing="2"
          RowSpacing="2"
          HorizontalOptions="Center"
          VerticalOptions="Center">
        <Label Text="{Binding Entry}"
               Grid.Row="0" Grid.Column="0" Grid.ColumnSpan="3"
               Margin="0,0,10,0"
               FontSize="32"
               LineBreakMode="HeadTruncation"
               VerticalTextAlignment="Center"
               HorizontalTextAlignment="End" />
        <Button Text="CLEAR"
                Grid.Row="1" Grid.Column="0" Grid.ColumnSpan="2"
                Command="{Binding ClearCommand}" />
        <Button Text="&#x21E6;"
                Grid.Row="1" Grid.Column="2"
                Command="{Binding BackspaceCommand}" />
        <Button Text="7"
                Grid.Row="2" Grid.Column="0"
                Command="{Binding DigitCommand}"
                CommandParameter="7" />
        <Button Text="8"
                Grid.Row="2" Grid.Column="1"
                Command="{Binding DigitCommand}"
                CommandParameter="8" />        
        <Button Text="9"
                Grid.Row="2" Grid.Column="2"
                Command="{Binding DigitCommand}"
                CommandParameter="9" />
        <Button Text="4"
                Grid.Row="3" Grid.Column="0"
                Command="{Binding DigitCommand}"
                CommandParameter="4" />
        <Button Text="5"
                Grid.Row="3" Grid.Column="1"
                Command="{Binding DigitCommand}"
                CommandParameter="5" />
        <Button Text="6"
                Grid.Row="3" Grid.Column="2"
                Command="{Binding DigitCommand}"
                CommandParameter="6" />
        <Button Text="1"
                Grid.Row="4" Grid.Column="0"
                Command="{Binding DigitCommand}"
                CommandParameter="1" />
        <Button Text="2"
                Grid.Row="4" Grid.Column="1"
                Command="{Binding DigitCommand}"
                CommandParameter="2" />
        <Button Text="3"
                Grid.Row="4" Grid.Column="2"
                Command="{Binding DigitCommand}"
                CommandParameter="3" />
        <Button Text="0"
                Grid.Row="5" Grid.Column="0" Grid.ColumnSpan="2"
                Command="{Binding DigitCommand}"
                CommandParameter="0" />
        <Button Text="&#x00B7;"
                Grid.Row="5" Grid.Column="2"
                Command="{Binding DigitCommand}"
                CommandParameter="." />
    </Grid>
</ContentPage>

Bu örnekte, sayfa BindingContext bir DecimalKeypadViewModelşeklindedir. Entry Bu görünüm modelinin özelliği, özelliğine Text Labelbağlıdır. Button Tüm nesneler görünüm modelindeki komutlara bağlıdır: ClearCommand, BackspaceCommandve DigitCommand. 10 basamak için 11 düğmesi ve ondalık noktası ile DigitCommandbir bağlama paylaşır. bu CommandParameter düğmeler arasında ayrımlar. olarak ayarlanan CommandParameter değer genellikle düğme tarafından görüntülenen metinle aynıdır, ancak ondalık ayırıcı hariç, netlik açısından orta nokta karakteriyle görüntülenir:

türündeki DecimalKeypadViewModel bir Entry özelliği ve türünün string ICommandüç özelliğini tanımlar:

public class DecimalKeypadViewModel : INotifyPropertyChanged
{
    string entry = "0";

    public event PropertyChangedEventHandler PropertyChanged;
    ···

    public string Entry
    {
        private set
        {
            if (entry != value)
            {
                entry = value;
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Entry"));
            }
        }
        get
        {
            return entry;
        }
    }

    public ICommand ClearCommand { private set; get; }
    public ICommand BackspaceCommand { private set; get; }
    public ICommand DigitCommand { private set; get; }
}

düğmesine karşılık gelen ClearCommand düğme her zaman etkindir ve girişi "0" olarak ayarlar:

public class DecimalKeypadViewModel : INotifyPropertyChanged
{
    ···
    public DecimalKeypadViewModel()
    {
        ClearCommand = new Command(
            execute: () =>
            {
                Entry = "0";
                RefreshCanExecutes();
            });
        ···
    }

    void RefreshCanExecutes()
    {
        ((Command)BackspaceCommand).ChangeCanExecute();
        ((Command)DigitCommand).ChangeCanExecute();
    }
    ···
}

Düğme her zaman etkinleştirildiğinden, oluşturucuda Command bir canExecute bağımsız değişken belirtmek gerekmez.

Geri Al düğmesi yalnızca girdinin uzunluğu 1'den büyükse veya "0" dizesine eşit değilse Entry etkinleştirilir:

public class DecimalKeypadViewModel : INotifyPropertyChanged
{
    ···
    public DecimalKeypadViewModel()
    {
        ···
        BackspaceCommand = new Command(
            execute: () =>
            {
                Entry = Entry.Substring(0, Entry.Length - 1);
                if (Entry == "")
                {
                    Entry = "0";
                }
                RefreshCanExecutes();
            },
            canExecute: () =>
            {
                return Entry.Length > 1 || Entry != "0";
            });
        ···
    }
    ···
}

Geri Al düğmesinin execute işlevinin mantığı, işlevinin Entry en az "0" dizesi olmasını sağlar.

DigitCommand özelliği, her biri kendisini özelliğiyle tanımlayan 11 düğmeye CommandParameter bağlıdır. DigitCommand sınıfının bir örneğine Command<T> ayarlanır. Komut arabirimini XAML ile kullanırken, CommandParameter özellikler genellikle genel bağımsız değişkenin türü olan dizelerdir. ve execute canExecute işlevleri daha sonra türünde stringbağımsız değişkenlere sahiptir:

public class DecimalKeypadViewModel : INotifyPropertyChanged
{
    ···
    public DecimalKeypadViewModel()
    {
        ···
        DigitCommand = new Command<string>(
            execute: (string arg) =>
            {
                Entry += arg;
                if (Entry.StartsWith("0") && !Entry.StartsWith("0."))
                {
                    Entry = Entry.Substring(1);
                }
                RefreshCanExecutes();
            },
            canExecute: (string arg) =>
            {
                return !(arg == "." && Entry.Contains("."));
            });
    }
    ···
}

yöntemi, execute dize bağımsız değişkenini özelliğine Entry ekler. Ancak, sonuç sıfırla (sıfır ve ondalık noktayla değil) başlıyorsa, ilk sıfır işlevi kullanılarak Substring kaldırılmalıdır. canExecute yöntemi yalnızca bağımsız değişken ondalık noktaysa (ondalık ayırıcıya basıldığını gösterir) ve Entry zaten bir ondalık nokta içeriyorsa döndürürfalse. execute Tüm yöntemler, hem hem de ClearCommandDigitCommand için çağrı yapan öğesini çağırırRefreshCanExecutesChangeCanExecute. Bu, girilen basamakların geçerli sırasına göre ondalık nokta ve geri al düğmelerinin etkinleştirilmesini veya devre dışı bırakılmasını sağlar.