Blog (5)
Komentarze (95)
Recenzje (0)

Piszemy prosty kalkulator w C#.NET - moja wersja

@matrix012345Piszemy prosty kalkulator w C#.NET - moja wersja16.02.2013 15:36

Po przeczytaniu wpisu użytkownika Description_1 postanowiłem zrobić to samo, ale lepiej.

Wykorzystam Microsoft Visual C# 2010 Express. W porównaniu z programem Descriptiona, mój nie będzie przezroczysty (nie wiem po co to było) oraz będzie napisany z użyciem XAMLa.

Zaczynamy

Tworzymy pusty projekt „WPF Application". Chwilowo zostawiamy główną klasę w spokoju i dodajemy klasę liczenie (w okienku „solution explorer” klikamy ppm na nazwę naszego projektu i wybieramy Add›Class...)

Dodawanie nowej klasy
Dodawanie nowej klasy

Dostaniemy coś w stylu:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Kalkulator
{
    class liczenie
    {
    }
}

Na górze zaimportowano nam cztery podstawowe przestrzenie nazw z bibliotek .NET. Nam wystarczy sam using System, ale dodatkowe przestrzenie nie powinny nam przeszkadzać. Cały nasz kod będzie znajdował się wewnątrz class liczenie {...}. Dopiszmy public przed class. Po co dowiemy się na końcu.

Będą nam potrzebne jakieś zmienne:

public double a = 0;
public double b = 0;
public char działanie;

a oraz b to liczby, które będziemy ze sobą dodawać, odejmować itp. działanie zawierać będzie znak informujący o tym, jakie działanie chcemy wykonać np. * albo /.

Double i char to typy zmiennych. Public oznacza, że możemy dostać się do zmiennej z zewnątrz naszej klasy.

Dodajmy metodę odpowiedzialną za liczenie:

public double licz()
        {
            if (działanie == '+')
                return a + b;
            if (działanie == '-')
                return a - b;
            if (działanie == '*')
                return a * b;
            if (działanie == '/')
                return a / b;
            if (działanie == '^')
                return Math.Pow(a,b);//znaku ^ nie można zastosować między dwiema liczbami typu double
            if (działanie == '!')
            {
                long s = 1;
                for (int i = 1; i <= a; ++i)
                    s *= i;
                return (double)s;
            }
            else
                return 0;
        }

W przypadku liczenia potęgi korzystamy z metody/funkcji Math.Pow, ponieważ zwykły zapis a^b nie zadziała dla liczb typu double. Dla obliczania silni wykorzystałem kod z wpisu użytkownika Description_1.

Tworzymy GUI

Przechodzimy do naszego pliku MainWindows.xaml. Dodajemy tam metodą przeciągnij i puść kontrolkę TextBox, w okienku „properties” we właściwości name wpisujemy pasekWyniku (nazwa ta będzie wiele razy używana w kodzie), i ustawiamy własność HorizontalContentAlignment na Right, przez co zawartość będzie wyrównana do prawej strony. Dodajemy kilka buttonów, rozmieszczamy i nazywamy je jakoś sensownie.

Do każdego butonu dodajemy zdarzenie click (dla wszystkich przycisków z liczbami możemy zrobić jedną wspólną metodę, tak samo dla wszystkich przycisków z działaniami matematycznymi jak np. dodawanie i odejmowanie; każdy inny przycisk musi mieć swoją własną)

Okienko properties ze wstawianiem zdarzeń
Okienko properties ze wstawianiem zdarzeń

Ostatecznie w okienku z kodem otrzymamy coś takiego:

<Window x:Class="Kalkulator.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="Mój program" mc:Ignorable="d" xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" Height="260" Width="265" MinWidth="265" MinHeight="260" MaxWidth="265" MaxHeight="260">
    <Grid>
        <TextBox Height="23" Name="pasekWyniku" VerticalAlignment="Top" TextChanged="pasekWyniku_TextChanged"  HorizontalContentAlignment="Right" />
        <Button Content="0" Height="40" Margin="12,167,0,0" Name="liczba0" VerticalAlignment="Top" HorizontalAlignment="Left" Width="40" Click="liczba_Click" />
        <Button Content="1" Height="40" Margin="12,121,0,0" Name="liczba1" VerticalAlignment="Top" HorizontalAlignment="Left" Width="40" Click="liczba_Click" />
        <Button Content="2" Height="40" Margin="104,121,0,0" Name="liczba2" VerticalAlignment="Top" HorizontalAlignment="Left" Width="40" Click="liczba_Click"  />
        <Button Content="3" Height="40" Margin="58,121,0,0" Name="liczba3" VerticalAlignment="Top" HorizontalAlignment="Left" Width="40" Click="liczba_Click"  />
        <Button Content="4" Height="40" Margin="12,75,0,0" Name="liczba4" VerticalAlignment="Top" HorizontalAlignment="Left" Width="40" Click="liczba_Click" />
        <Button Content="5" Height="40" Margin="104,75,0,0" Name="liczba5" VerticalAlignment="Top" HorizontalAlignment="Left" Width="40" Click="liczba_Click"  />
        <Button Content="6" Height="40" Margin="58,75,0,0" Name="liczba6" VerticalAlignment="Top" HorizontalAlignment="Left" Width="40" Click="liczba_Click"  />
        <Button Content="7" Height="40" Margin="12,29,0,0" Name="liczba7" VerticalAlignment="Top" HorizontalAlignment="Left" Width="40" Click="liczba_Click" />
        <Button Content="8" Height="40" Margin="105,30,0,0" Name="liczba8" VerticalAlignment="Top" HorizontalAlignment="Left" Width="40" Click="liczba_Click"  />
        <Button Content="9" Height="40" Margin="58,29,0,0" Name="liczba9" VerticalAlignment="Top" HorizontalAlignment="Left" Width="40" Click="liczba_Click"  />
        <Button Content="=" Height="40" Margin="104,167,0,0" Name="wynik" VerticalAlignment="Top" HorizontalAlignment="Left" Width="40" Click="wynik_Click"  />
        <Button Content="," Height="40" Margin="58,167,0,0" Name="przecinek" VerticalAlignment="Top" HorizontalAlignment="Left" Width="40" Click="przecinek_Click"  />
        <Button Content="*" Height="40" Margin="151,30,0,0" Name="mnożenie" VerticalAlignment="Top" HorizontalAlignment="Left" Width="40" Click="działanie_Click"  />
        <Button Content="/" Height="40" Margin="198,30,0,0" Name="dzielenie" VerticalAlignment="Top" HorizontalAlignment="Left" Width="40" Click="działanie_Click" />
        <Button Content="+" Height="40" Margin="151,121,0,0" Name="dodawanie" VerticalAlignment="Top" HorizontalAlignment="Left" Width="40" Click="działanie_Click"  />
        <Button Content="-" Height="40" Margin="151,75,0,0" Name="odejmowanie" VerticalAlignment="Top" HorizontalAlignment="Left" Width="40" Click="działanie_Click"  />
        <Button Content="^" Height="40" Margin="198,75,0,0" Name="potęga" VerticalAlignment="Top" HorizontalAlignment="Left" Width="40" Click="działanie_Click"  />
        <Button Content="N!" Height="40" Margin="198,121,0,0" Name="silnia" VerticalAlignment="Top" HorizontalAlignment="Left" Width="40"  Click="silnia_Click" />
        <Button Content="bin" Height="40" Margin="151,167,0,0" Name="systemBinarny" VerticalAlignment="Top" HorizontalAlignment="Left" Width="40"  Click="systemBinarny_Click" />
        <Button Content="cls" Height="40" HorizontalAlignment="Left" Margin="198,167,0,0" Name="czyszczenie" VerticalAlignment="Top" Width="40" Click="czyszczenie_Click"  />
    </Grid>
</Window>
A takie coś otrzymamy graficznie
A takie coś otrzymamy graficznie

przechodzimy do pliku MainWindow.xaml.cs. Zaraz po deklaracji klasy (public partial class MainWindow : Window) tworzymy sobie nowy obiekt typu liczenie

liczenie liczenie = new liczenie();

Poniewarz chcemy (przynajmniej ja chcę) naśladować kalkulator windowsowy, potrzebne będą nam dwie zmienne:


bool gdzieWpisać=true;
bool czyWyczyścićPasekWyniku = false;

gdzieWpisać zawiera informację, która liczba (a czy b) z obiektu liczenie będzie zmieniana przy wpisaniu jakiejś liczby w pole tekstowe.

czyWyczyścićPasekWyniku informuje, czy po kliknięciu w jakąś cyfrę zostanie ona dopisana na koniec obecnie wyświetlanej liczby czy pole to zostanie wyczyszczone.

Zabierzmy się więc za poszczególne zdarzenia. Jeśli utworzyliśmy zdarzenie podczas edycji pliku MainWindow.xaml to powinniśmy mieć już puste metody dla każdego przycisku.

Dla wszystkich przycisków z cyframi użyjmy takiej oto metody

private void liczba_Click(object sender, RoutedEventArgs e)
        {
            if (czyWyczyścićPasekWyniku)
                pasekWyniku.Text = (sender as Button).Content.ToString();
            else
                pasekWyniku.Text += (sender as Button).Content.ToString();
            czyWyczyścićPasekWyniku = false;
        }

Wykorzystałem tutaj pomysł użytkownika Jim1961 na wykorzystanie własności Content.ToString(). Jeśli czyWyczyścićPasekWyniku jest równe true, to wartość pola tekstowego „pasekWyniku” będzie równa tekstowi na naszym przycisku, a jeśli false to zostanie dopisany na końcu.

Dla przecinka:

 private void przecinek_Click(object sender, RoutedEventArgs e)
        {
            if (czyWyczyścićPasekWyniku)
                pasekWyniku.Text = "0,";
            else
                pasekWyniku.Text += ",";
            czyWyczyścićPasekWyniku = false;
        }

Tu jest podobnie, z tym że jeśli czyścimy pole tekstowe to dodajemy 0 na początku, by jakoś to wyglądało.

Przycisk z działaniami typu dodawanie czy mnożenie: [code=csharp]private void działanie_Click(object sender, RoutedEventArgs e) { liczenie.działanie = (sender as Button).Content.ToString()[0]. czyWyczyścićPasekWyniku=true;//czyścimy pasek tekstowy gdzieWpisać = false; }[/code]

zmiennej działanie w obiekcie liczenie przymisujemy znak odpowiedniego działania. Korzystam tu z metody first() aby wyciągnąć typ char z typu string.


        private void silnia_Click(object sender, RoutedEventArgs e)
        {

            liczenie.działanie = '!';
            gdzieWpisać = true;
            liczenie.a = liczenie.licz();
            pasekWyniku.Text = liczenie.a.ToString();//wyświetlamy wynik
            czyWyczyścićPasekWyniku = true;
        }

Dla obliczenia silni nie potrzeba drugiej liczby, więc od razu wyliczamy wynik.

private void pasekWyniku_TextChanged(object sender, TextChangedEventArgs e)
        {
             try{   if (gdzieWpisać)
                    liczenie.a = double.Parse(pasekWyniku.Text);
                else
                    liczenie.b = double.Parse(pasekWyniku.Text);
            }
            catch(FormatException wyjątek)//jeśli wprowadzono błędnie liczbę wykonuje poniższy kod
             {if(pasekWyniku.Text!="")
                MessageBox.Show("Nie wpisano prawidłowo liczby", "Błąd", MessageBoxButton.OK, MessageBoxImage.Error);//komunikat o błędzie, ale tylko, jeśli pole nie jest puste
        }
        }

Kiedy zmienia się treść w polu tekstowym zmieniamy także liczbę w obiekcie liczenie. Jeżeli użytkownik wpisze w pole nieprawidłową liczbę zostanie zwrócony wyjątek FormatException i wyświetlony będzie komunikat o błędzie.

Naciskając przycisk cls czyścimy podstawowe zmienne:

 private void czyszczenie_Click(object sender, RoutedEventArgs e)
        {
            liczenie.a = liczenie.b = 0;
            liczenie.działanie = ' ';
            pasekWyniku.Text = "";
            czyWyczyścićPasekWyniku = false;
            gdzieWpisać = true;
        }

Dla przycisku bin zamieniamy liczbę zmiennoprzecinkową double na całkowitą int i konwertujemy na format dwójkowy.


        private void systemBinarny_Click(object sender, RoutedEventArgs e)
        {
            pasekWyniku.Text = Convert.ToString((int)liczenie.a, 2);
        }

Kompilujemy (przycisk F5)! W ten oto sposób mamy gotowy kalkulator.

Bonus - szybkie portowanie

Pokażę teraz jak szybko przerobić nasz projekt np. na wersję konsolową albo Windows Phone.

Konsola Windows

Ponieważ nasza klasa liczenie jest publiczna, możemy dostać się do niej nawet z innych projektów Visual Studio.

Stwórzmy sobie nowy projekt, tym razem aplikację konsolową. W okienku „Solution Explorer” klikamy ppm na „references” i wybieramy „Add reference”. W karcie „Browse” wybieramy nasz plik exe stworzony przed chwilą.

Przejdźmy do pliku program.cs. Na początku dopiszmy nazwę naszej przestrzeni nazw z poprzedniego projektu (w moim przypadku był to „Kalkulator”, można ją poszukać w Object Browserze) i już mamy dostęp do naszej klasy:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Kalkulator;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            if (args.Length > 2)
            {
                liczenie liczenie = new liczenie();
                liczenie.a = double.Parse(args[0]);
                liczenie.b = double.Parse(args[2]);
                liczenie.działanie = args[1].Last();
                Console.WriteLine(liczenie.licz().ToString());
            }
            else
                Console.WriteLine("Za mało parametrów");
        }
    }
}
Kalkulator w konsoli CMD
Kalkulator w konsoli CMD

I oto mamy kalkulator uruchamiany z wiersza polecenia. W ten sposób wykorzystaliśmy klasę bez użycia kodu źródłowego, mając dostęp tylko do pliku exe. Oczywiście plik ten musi być w tym samym folderze co aplikacja konsolowa aby się uruchomił.

Windows Phone

Tutaj sprawa wygląda trochę inaczej. Nie możemy zaimportować pliku exe, ale też nie powinno sprawić żadnych problemów. Korzystamy tutaj z Visual Studio Express 2012 for Windows Phone.

Najpierw tworzymy nowy projekt:

Tworzenie nowego projektu
Tworzenie nowego projektu

Następnie metodą przeciągnij i puść (drag and drop) kopiujemy plik liczenie.cs:

Otwieramy plik MainPage.xaml.cs i dopisujemy na początku linię:

using Kalkulator;

następnie do wewnątrz klasy (po public partial class MainPage : PhoneApplicationPage {) kopiujemy całą zawartość klasy z pliku MainWindow.xaml.cs z projektu aplikacji okienkowej. Kasujemy fragment

public MainWindow()
        {
            InitializeComponent();
        }

Zmienaimy też linię

MessageBox.Show("Nie wpisano prawidłowo liczby", "Błąd", MessageBoxButton.OK, MessageBoxImage.Error);

na

MessageBox.Show("Nie wpisano prawidłowo liczby", "Błąd", MessageBoxButton.OK);

Przechodzimy do pliku MainPage.xaml. Z kodu pliku MainWindow.xaml projektu aplikacji pulpitowej kopiujemy wszystko między <Grid> a </Grid> a następnie wklejamy po <Grid x:Name="ContentPanel" Grid.Row="1" Margin="12,0,12,0"> do projektu Windows Phone. Na razie nie będzie to wyglądało za dobrze. W TextBoxie i wszystkich Buttonach zmieniamy wartości Width i Height lub po prostu rozciągamy je w widoku graficznym. Na koniec układamy jakoś sensownie nasze kontrolki. Dostaniemy coś w stylu: [code=xml]<phone:PhoneApplicationPage x:Class="KalkulatorWindowsPhone.MainPage" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:phone="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone" xmlns:shell="clr-namespace:Microsoft.Phone.Shell;assembly=Microsoft.Phone" xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" mc:Ignorable="d" d:DesignWidth="480" d:DesignHeight="768" FontFamily="{StaticResource PhoneFontFamilyNormal}" FontSize="{StaticResource PhoneFontSizeNormal}" Foreground="{StaticResource PhoneForegroundBrush}" SupportedOrientations="Portrait" Orientation="Portrait" shell:SystemTray.IsVisible="True"> <Grid x:Name="LayoutRoot" Background="Transparent"> <Grid.RowDefinitions> <RowDefinition Height="Auto"/> <RowDefinition Height="*"/> </Grid.RowDefinitions> <StackPanel x:Name="TitlePanel" Grid.Row="0" Margin="12,17,0,28"> <TextBlock x:Name="PageTitle" Text="Kalkulator" Margin="9,-7,0,0" Style="{StaticResource PhoneTextTitle1Style}"/> </StackPanel> <Grid x:Name="ContentPanel" Grid.Row="1" Margin="10,0,14,0"> <TextBox Name="pasekWyniku" VerticalAlignment="Top" TextChanged="pasekWyniku_TextChanged" HorizontalContentAlignment="Right" />

Emulator Windows Phone
Emulator Windows Phone

Windows 8

Sprawa Windows 8 wygląda analogicznie jak Windows Phone, z tym że kasujemy: [code=csharp]if (pasekWyniku.Text != "") MessageBox.Show("Nie wpisano prawidłowo liczby", "Błąd", MessageBoxButton.OK, MessageBoxImage.Error);[/code]

a do pliku MainPage.xaml wklejamy po: [code=csharp]<Grid Background="{StaticResource ApplicationPageBackgroundThemeBrush}">[/code]

tl;dr

Link do pobrania

Zdjęcie rodzinne ;)
Zdjęcie rodzinne ;)
Szanowna Użytkowniczko! Szanowny Użytkowniku!
×
Aby dalej móc dostarczać coraz lepsze materiały redakcyjne i udostępniać coraz lepsze usługi, potrzebujemy zgody na dopasowanie treści marketingowych do Twojego zachowania. Twoje dane są u nas bezpieczne, a zgodę możesz wycofać w każdej chwili na podstronie polityka prywatności.

Kliknij "PRZECHODZĘ DO SERWISU" lub na symbol "X" w górnym rogu tej planszy, jeżeli zgadzasz się na przetwarzanie przez Wirtualną Polskę i naszych Zaufanych Partnerów Twoich danych osobowych, zbieranych w ramach korzystania przez Ciebie z usług, portali i serwisów internetowych Wirtualnej Polski (w tym danych zapisywanych w plikach cookies) w celach marketingowych realizowanych na zlecenie naszych Zaufanych Partnerów. Jeśli nie zgadzasz się na przetwarzanie Twoich danych osobowych skorzystaj z ustawień w polityce prywatności. Zgoda jest dobrowolna i możesz ją w dowolnym momencie wycofać zmieniając ustawienia w polityce prywatności (w której znajdziesz odpowiedzi na wszystkie pytania związane z przetwarzaniem Twoich danych osobowych).

Od 25 maja 2018 roku obowiązuje Rozporządzenie Parlamentu Europejskiego i Rady (UE) 2016/679 (określane jako "RODO"). W związku z tym chcielibyśmy poinformować o przetwarzaniu Twoich danych oraz zasadach, na jakich odbywa się to po dniu 25 maja 2018 roku.

Kto będzie administratorem Twoich danych?

Administratorami Twoich danych będzie Wirtualna Polska Media Spółka Akcyjna z siedzibą w Warszawie, oraz pozostałe spółki z grupy Wirtualna Polska, jak również nasi Zaufani Partnerzy, z którymi stale współpracujemy. Szczegółowe informacje dotyczące administratorów znajdują się w polityce prywatności.

O jakich danych mówimy?

Chodzi o dane osobowe, które są zbierane w ramach korzystania przez Ciebie z naszych usług, portali i serwisów internetowych udostępnianych przez Wirtualną Polskę, w tym zapisywanych w plikach cookies, które są instalowane na naszych stronach przez Wirtualną Polskę oraz naszych Zaufanych Partnerów.

Dlaczego chcemy przetwarzać Twoje dane?

Przetwarzamy je dostarczać coraz lepsze materiały redakcyjne, dopasować ich tematykę do Twoich zainteresowań, tworzyć portale i serwisy internetowe, z których będziesz korzystać z przyjemnością, zapewniać większe bezpieczeństwo usług, udoskonalać nasze usługi i maksymalnie dopasować je do Twoich zainteresowań, pokazywać reklamy dopasowane do Twoich potrzeb. Szczegółowe informacje dotyczące celów przetwarzania Twoich danych znajdują się w polityce prywatności.

Komu możemy przekazać dane?

Twoje dane możemy przekazywać podmiotom przetwarzającym je na nasze zlecenie oraz podmiotom uprawnionym do uzyskania danych na podstawie obowiązującego prawa – oczywiście tylko, gdy wystąpią z żądaniem w oparciu o stosowną podstawę prawną.

Jakie masz prawa w stosunku do Twoich danych?

Masz prawo żądania dostępu, sprostowania, usunięcia lub ograniczenia przetwarzania danych. Możesz wycofać zgodę na przetwarzanie, zgłosić sprzeciw oraz skorzystać z innych praw wymienionych szczegółowo w polityce prywatności.

Jakie są podstawy prawne przetwarzania Twoich danych?

Podstawą prawną przetwarzania Twoich danych w celu świadczenia usług jest niezbędność do wykonania umów o ich świadczenie (tymi umowami są zazwyczaj regulaminy). Podstawą prawną przetwarzania danych w celu pomiarów statystycznych i marketingu własnego administratorów jest tzw. uzasadniony interes administratora. Przetwarzanie Twoich danych w celach marketingowych realizowanych przez Wirtualną Polskę na zlecenie Zaufanych Partnerów i bezpośrednio przez Zaufanych Partnerów będzie odbywać się na podstawie Twojej dobrowolnej zgody.