Calender Control, SelectionMode=MultiplyRange

  • WPF

Es gibt 26 Antworten in diesem Thema. Der letzte Beitrag () ist von MichaHo.

    @Akanel Mir ist durchaus bewusst, dass @Nofear23m hier explizit von einem Attached Property gesprochen hatte, aber, und bitte korrigiert mich wenn ich falsch liege es geht doch darum, das man eine Property in seinem ViewModel, mit den im CalendarControl ausgewählten Datetimes füllen möchte, und soweit ich den Artikel unter dem von mir geposteten Link aktuell verstehe, ermöglicht diese methode doch eine ReadOnly-Property (Das wäre ja vom Calendar die "SelectedDates" ) trotzden zu binden ? Wie gesagt so versteh ich das aktuell und es ist durchaus möglich das ich komplett falsch liege.

    LG


    Nachtrag:

    Und C# Code kann man problemlos durch einen Konverter jagen um ihn dann zu verstehen.


    kenne bisher leider keinen bei dem ich komplette Projektmappen einfach konvertieren kann ?

    If Energy = Low Then
    Drink(aHugeCoffee)
    Else
    Drink(aHugeCoffeeToo)
    End If

    Ich bin mir mittlerweile auch garnicht mehr sicher ob hier ein Attached Prperty überhaupt hilft, denn ich will ja nicht vom ViewModel Daten an die View schicken sondern anders rum. User selektiert mehrere Datumse, Dirse sollen dann an mein Property geschickt werden und niemals andersrum. Im ViewModel werden diese Datumse nur in einer ForEach Schleife benötigt. Bei meinen Tests wurde auch nie das Attached Property erreicht, immer nur dann wenn ich im ViewModel der Property händisch daten hinzugefügt habe. Deshalb hab ich jetzt einfach im CodeBehind über das Event mein Property gefüllt.
    Im Netz gab es auch ein Beispiel, allerdings für die BlackOutDates, kommt aber aufs selbe raus. Aber auch dort wurden die Datumse im ViewModel hinzugefügt.

    P.S. Ich guck mir den Link dennoch morgen mal genauer an
    "Hier könnte Ihre Werbung stehen..."

    Ich bin im Moment im Stress und werde erdt morgen dazu kommen ein Beispiel zu erstellen. Aber es ist egal in welche Rochtung man die Daten benötigt. Du benötigst egal in welche Richtung ein Property. Wenn du es nur in Richtung ViewModel benötigst um dort zu wissen welche Datumsrange selektiert wurde kannst du ja das vorhandene Property nutzen da in diesem Fall ja ein ReadOnly Property reicht. Musst du es eben OneWayToSource binden. Zumindest wenn ich das richtig verstehe.

    Grüße
    Sascha
    If _work = worktype.hard Then Me.Drink(Coffee)
    Seht euch auch meine Tutorialreihe <WPF Lernen/> an oder abonniert meinen YouTube Kanal.

    ## Bitte markiere einen Thread als "Erledigt" wenn deine Frage beantwortet wurde. ##

    Habe es nun folgendermaßen versucht und funktioniert zumindest ( bitte keine haue, ist aufgrund von Faulheit beim testen ohne extra ViewModel gemacht):


    MainWindow-Xaml:
    Spoiler anzeigen

    XML-Quellcode

    1. <Window x:Class="MainWindow"
    2. xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    3. xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    4. xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    5. xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    6. xmlns:local="clr-namespace:AttachedPropTest"
    7. mc:Ignorable="d"
    8. Title="MainWindow" Height="450" Width="800" DataContext="{Binding RelativeSource={RelativeSource Self}}">
    9. <Grid>
    10. <StackPanel>
    11. <local:CalendarEX SelectionMode="MultipleRange" SelectedDateMirror="{Binding SelectedDatesVM, Mode=OneWayToSource, UpdateSourceTrigger=PropertyChanged}"></local:CalendarEX>
    12. <Button Click="Button_Click">test</Button>
    13. </StackPanel>
    14. </Grid>
    15. </Window>


    MainWindow-CodeBehind:
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Imports System.Collections.ObjectModel
    2. Imports System.ComponentModel
    3. Imports System.Runtime.CompilerServices
    5. Class MainWindow
    6. Implements INotifyPropertyChanged
    8. Private _selecteddatesvm As New ObservableCollection(Of DateTime)
    9. Public Property SelectedDatesVM() As ObservableCollection(Of DateTime)
    10. Get
    11. Return _selecteddatesvm
    12. End Get
    13. Set(ByVal value As ObservableCollection(Of DateTime))
    14. _selecteddatesvm = value
    15. RaisePropertyChanged()
    16. End Set
    17. End Property
    19. Private Sub Button_Click(sender As Object, e As RoutedEventArgs)
    20. For Each dt As DateTime In SelectedDatesVM
    21. MessageBox.Show(dt.ToLongDateString)
    22. Next
    23. End Sub
    25. Public Event PropertyChanged As PropertyChangedEventHandler Implements INotifyPropertyChanged.PropertyChanged
    26. Protected Overridable Sub RaisePropertyChanged(<CallerMemberName> Optional ByVal prop As String = "")
    27. RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs(prop))
    28. End Sub
    29. End Class


    und CalendarEX-Klasse:
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Imports System.ComponentModel
    2. Imports System.Runtime.CompilerServices
    4. Public Class CalendarEX
    5. Inherits Calendar
    7. Public Property SelectedDateMirror As IEnumerable(Of DateTime)
    8. Get
    9. Return GetValue(SelectedDateMirrorProperty)
    10. End Get
    12. Set(ByVal value As IEnumerable(Of DateTime))
    13. SetValue(SelectedDateMirrorProperty, value)
    14. End Set
    15. End Property
    17. Public Shared ReadOnly SelectedDateMirrorProperty As DependencyProperty =
    18. DependencyProperty.Register("SelectedDateMirror",
    19. GetType(IEnumerable(Of DateTime)), GetType(CalendarEX),
    20. New PropertyMetadata(Nothing))
    22. Private Sub CalendarEX_SelectedDatesChanged(sender As Object, e As SelectionChangedEventArgs) Handles Me.SelectedDatesChanged
    23. SelectedDateMirror = Me.SelectedDates
    24. End Sub
    26. End Class
    If Energy = Low Then
    Drink(aHugeCoffee)
    Else
    Drink(aHugeCoffeeToo)
    End If

    Hi,
    @asusdk Danke Dir für Deinen Test.
    Ich hab nochmal ein neues Projekt erstellt und es dort ausgetestet.
    Mit einer Extra Kalenderklasse wie oben kallpt es mit einem DependencyProperty. Mit einem AttachedProperty klappt es nicht...
    Ich musste allerdings etwas die Calenderklasse anpassen. Da ich von Calendar ableite, kann man die entsprechenden Events ja überschreiben.
    Klappt bestens.

    XAML:

    XML-Quellcode

    1. <Window x:Class="CalendarSample2.MainWindow"
    2. xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    3. xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    4. xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    5. xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    6. xmlns:local="clr-namespace:CalendarSample2"
    7. mc:Ignorable="d"
    8. Title="MainWindow" Height="450" Width="800">
    9. <Grid>
    10. <Grid.RowDefinitions>
    11. <RowDefinition Height="Auto"/>
    12. <RowDefinition Height="*"/>
    13. </Grid.RowDefinitions>
    14. <local:CalendarEx Grid.Row="0"
    15. SelectionMode="MultipleRange"
    16. SelectedDate="{Binding SelectedDate}"
    17. SelectedDatesEx="{Binding SelectedDates, Mode=OneWayToSource, UpdateSourceTrigger=PropertyChanged}"/>
    18. <ListView Grid.Row="1"
    19. ItemsSource="{Binding SelectedDates}"/>
    21. </Grid>
    22. </Window>


    Xaml.cs:

    C#-Quellcode

    1. using System.Windows;
    3. namespace CalendarSample2
    4. {
    5. /// <summary>
    6. /// Interaction logic for MainWindow.xaml
    7. /// </summary>
    8. public partial class MainWindow : Window
    9. {
    10. public MainWindow()
    11. {
    12. InitializeComponent();
    13. DataContext = new MainViewModel();
    14. }
    15. }
    16. }


    ViewModel:

    C#-Quellcode

    1. using System;
    2. using System.Collections.ObjectModel;
    3. using System.ComponentModel;
    4. using System.Runtime.CompilerServices;
    6. namespace CalendarSample2
    7. {
    8. public class MainViewModel : INotifyPropertyChanged
    9. {
    11. private DateTime _selectedDate;
    13. public DateTime SelectedDate
    14. {
    15. get { return _selectedDate; }
    16. set { _selectedDate = value; OnPropertyChanged(); }
    17. }
    19. private ObservableCollection<DateTime> _selectedDates = new ObservableCollection<DateTime>();
    21. public ObservableCollection<DateTime> SelectedDates
    22. {
    23. get { return _selectedDates; }
    24. set { _selectedDates = value; OnPropertyChanged(); }
    25. }
    27. #region INotifyPropertyChanged
    28. public event PropertyChangedEventHandler PropertyChanged;
    29. protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
    30. {
    31. PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    32. }
    33. #endregion
    35. }
    36. }


    CalendarEx Klasse:

    C#-Quellcode

    1. using System.Windows;
    2. using System.Windows.Controls;
    4. namespace CalendarSample2
    5. {
    6. public class CalendarEx : Calendar
    7. {
    8. public SelectedDatesCollection SelectedDatesEx
    9. {
    10. get => (SelectedDatesCollection)GetValue(SelectedDatesExProperty);
    11. set => SetValue(SelectedDatesExProperty, value);
    12. }
    14. // Using a DependencyProperty as the backing store for SelectedDatesEx. This enables animation, styling, binding, etc...
    15. public static readonly DependencyProperty SelectedDatesExProperty =
    16. DependencyProperty.Register("SelectedDatesEx", typeof(SelectedDatesCollection), typeof(CalendarEx), new PropertyMetadata(null));
    18. protected override void OnSelectedDatesChanged(SelectionChangedEventArgs e)
    19. {
    20. SelectedDatesEx = this.SelectedDates;
    21. }
    23. }
    24. }


    sieht dann so aus (abgesehen von der bescheuerten Formatierung des Datums. Ist bei mir IMMER Amerikanisch, warum auch immer):
    "Hier könnte Ihre Werbung stehen..."

    im designer isses bei mir auch immer Hohlbrotisch aber mit der entsprechenden Culture im Programm nichmehr


    Application.Xaml.VB:

    VB.NET-Quellcode

    1. Imports System.Globalization
    2. Imports System.Runtime.CompilerServices
    3. Imports System.Runtime.InteropServices
    4. Imports System.Text.RegularExpressions
    5. Imports System.Threading
    6. Imports System.Windows.Markup
    8. Class Application
    10. Public Shared ReadOnly Property StartUpPath As String = System.IO.Path.GetDirectoryName(System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName)
    11. Public Shared ReadOnly Property DataBasePath As String = $"{System.IO.Path.GetDirectoryName(System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName)}\Data"
    13. Private Sub Application_Startup(sender As Object, e As StartupEventArgs) Handles Me.Startup
    14. SetCultureProgramWide(New CultureInfo("de-DE"))
    15. End Sub
    17. Private Sub SetCultureProgramWide(newCulture As CultureInfo)
    18. Dim currentCulture As CultureInfo = newCulture
    19. Thread.CurrentThread.CurrentCulture = currentCulture
    20. Thread.CurrentThread.CurrentUICulture = currentCulture
    21. CultureInfo.DefaultThreadCurrentCulture = currentCulture
    22. CultureInfo.DefaultThreadCurrentUICulture = currentCulture
    23. FrameworkElement.LanguageProperty.OverrideMetadata(GetType(FrameworkElement), New FrameworkPropertyMetadata(XmlLanguage.GetLanguage(CultureInfo.CurrentCulture.IetfLanguageTag)))
    24. End Sub
    26. End Class

    If Energy = Low Then
    Drink(aHugeCoffee)
    Else
    Drink(aHugeCoffeeToo)
    End If

    Hi,
    japp, das hatte ich in einem meiner anderen Projekte auch drin und mich nu wieder erinnert:

    C#-Quellcode

    1. public partial class App : Application
    2. {
    3. public App()
    4. {
    5. FrameworkElement.LanguageProperty.OverrideMetadata(typeof(FrameworkElement),
    6. new FrameworkPropertyMetadata(XmlLanguage.GetLanguage
    7. (CultureInfo.CurrentCulture.IetfLanguageTag)));
    8. }
    9. }


    und schon wird alles schön angezeigt.

    Mir gefällt DP und AP immer besser :)
    hab die CalendarEx nu noch was angepasst.
    Jetzt werden im Kalender die vergangenen Datumse durchgestrichen und die Wochenenden plus Feiertage der künftigen Datumse auch...



    hier noch die beiden Klassen:
    CalendarEx:
    Spoiler anzeigen

    C#-Quellcode

    1. using System;
    2. using System.Windows;
    3. using System.Windows.Controls;
    5. namespace CalendarSample
    6. {
    7. public class CalendarEx : Calendar
    8. {
    9. #region DependencyProperties
    11. public SelectedDatesCollection SelectedDatesEx
    12. {
    13. get => (SelectedDatesCollection)GetValue(SelectedDatesExProperty);
    14. set => SetValue(SelectedDatesExProperty, value);
    15. }
    17. // Using a DependencyProperty as the backing store for SelectedDatesEx. This enables animation, styling, binding, etc...
    18. public static readonly DependencyProperty SelectedDatesExProperty =
    19. DependencyProperty.Register("SelectedDatesEx", typeof(SelectedDatesCollection), typeof(CalendarEx), new PropertyMetadata(null));
    21. #endregion
    23. #region Attached Properties
    25. public static DateTime GetAddBlackoutDates(DependencyObject obj)
    26. {
    27. return (DateTime)obj.GetValue(AddBlackoutDatesProperty);
    28. }
    30. public static void SetAddBlackoutDates(DependencyObject obj, bool value)
    31. {
    32. obj.SetValue(AddBlackoutDatesProperty, value);
    33. }
    35. // Using a DependencyProperty as the backing store for AddBlackoutDates. This enables animation, styling, binding, etc...
    36. public static readonly DependencyProperty AddBlackoutDatesProperty =
    37. DependencyProperty.RegisterAttached("AddBlackoutDates", typeof(DateTime), typeof(CalendarEx), new PropertyMetadata(AddBlackoutDatesChanged));
    39. private static void AddBlackoutDatesChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    40. {
    41. var cal = d as Calendar;
    42. var yearDays = cal.DisplayDate.GetAllYearDates();
    43. foreach (var date in yearDays)
    44. {
    45. if (date.IsWeekend() || date.IsHoliday(DateTimeHelper.FederalStateEnum.Hessen))
    46. cal.BlackoutDates.Add(new CalendarDateRange(date));
    47. }
    48. }
    50. #endregion
    52. #region Overrides
    54. protected override void OnSelectedDatesChanged(SelectionChangedEventArgs e)
    55. {
    56. SelectedDatesEx = this.SelectedDates;
    57. }
    59. protected override void OnInitialized(EventArgs e)
    60. {
    61. base.OnInitialized(e);
    62. this.BlackoutDates.AddDatesInPast();
    63. }
    65. #endregion
    67. }
    68. }


    und die Helper dazu:
    Spoiler anzeigen

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Globalization;
    5. namespace CalendarSample
    6. {
    7. public static class DateTimeHelper
    8. {
    9. #region Week Methods
    10. /// <summary>
    11. /// Gibt zum angegebenen Datum den ersten Tag der Woche zurück.
    12. /// </summary>
    13. /// <param name="date">das zu prüfende Datum</param>
    14. /// <returns></returns>
    15. public static DateTime GetFirstDayOfWeek(this DateTime date)
    16. {
    17. return date.GetFirstDayOfWeek(CultureInfo.CurrentCulture);
    18. }
    20. /// <summary>
    21. /// Gibt zum angegebenen Datum den ersten Tag der Woche in der entsprechenen Kultur zurück.
    22. /// </summary>
    23. /// <param name="date">das zu prüfende Datum</param>
    24. /// <param name="cultureInfo">Kultur</param>
    25. /// <returns></returns>
    26. public static DateTime GetFirstDayOfWeek(this DateTime date, CultureInfo cultureInfo)
    27. {
    28. var day = date.Date;
    29. while (day.DayOfWeek != cultureInfo.DateTimeFormat.FirstDayOfWeek)
    30. {
    31. day = day.AddDays(-1);
    32. }
    33. return day;
    34. }
    35. #endregion
    37. #region Month Methods
    39. /// <summary>
    40. /// Gibt den letzten Tag des Monats des angegebenen Datums zurück.
    41. /// </summary>
    42. /// <param name="date">das zu prüfende Datum</param>
    43. /// <returns></returns>
    44. public static DateTime GetLastDayOfMonth(this DateTime date)
    45. {
    46. return new DateTime(date.Year, date.Month, DateTime.DaysInMonth(date.Year, date.Month));
    47. }
    49. #endregion
    51. #region Year Methods
    53. /// <summary>
    54. /// Gibt alle Datumse des Jahres als Liste zurück
    55. /// </summary>
    56. /// <param name="date">das Datum</param>
    57. /// <returns></returns>
    58. public static List<DateTime> GetAllYearDates(this DateTime date)
    59. {
    60. var result = new List<DateTime>();
    61. for (int i = 1; i < 13; i++)
    62. {
    63. for (int j = 1; j < DateTime.DaysInMonth(date.Year, i) + 1; j++)
    64. {
    65. result.Add(new DateTime(date.Year, i, j));
    66. }
    67. }
    68. return result;
    69. }
    71. #endregion
    73. #region Bool Methods
    75. /// <summary>
    76. /// Prüft, ob der Tag auf ein Wochenende fällt.
    77. /// </summary>
    78. /// <param name="date">das zu prüfende Datum</param>
    79. /// <returns>True, falls Wochenende, False falls nicht</returns>
    80. public static bool IsWeekend(this DateTime date)
    81. {
    82. return date.DayOfWeek == DayOfWeek.Saturday
    83. || date.DayOfWeek == DayOfWeek.Sunday;
    84. }
    86. /// <summary>
    87. /// Prüft ob das angegebene Datum ein Feiertag ist
    88. /// </summary>
    89. /// <param name="date">das zu prüfende Datum</param>
    90. /// <returns></returns>
    91. public static bool IsHoliday(this DateTime date)
    92. {
    93. return date.IsHoliday(FederalStateEnum.Invariant);
    94. }
    96. /// <summary>
    97. /// Prüft ob das angegebene Datum ein Feiertag ist
    98. /// </summary>
    99. /// <param name="date">das zu prüfende Datum</param>
    100. /// <param name="state">Bundesland, für das der Feiertag geprüft werden soll</param>
    101. /// <returns></returns>
    102. public static bool IsHoliday(this DateTime date, FederalStateEnum state)
    103. {
    104. return date.GetHolidays(state).Contains(date.Date);
    105. }
    107. #endregion
    109. #region WorkDay Methods
    111. /// <summary>
    112. /// gibt die Anzahl der Arbeitstage zurück
    113. /// </summary>
    114. /// <param name="dtStart">das Start Datum</param>
    115. /// <param name="dtEnd"> das End Datum</param>
    116. /// <returns></returns>
    117. public static int GetWorkDays(this DateTime dtStart, DateTime dtEnd)
    118. {
    119. if (dtStart >= dtEnd)
    120. dtStart = dtStart.AddMonths(-1);
    121. int Days = dtEnd.Subtract(dtStart).Days + 1;
    122. for (int i = 0; i <= Days - 1; i++)
    123. {
    124. if (dtStart.AddDays(i).IsHoliday() || dtStart.AddDays(i).IsWeekend())
    125. Days -= 1;
    126. }
    127. return Days;
    128. }
    129. /// <summary>
    130. /// prüft ob das angegebene Datum ein Arbeitstag ist
    131. /// </summary>
    132. /// <param name="date">das zu prüfende Datum</param>
    133. /// <returns></returns>
    134. public static bool IsWorkDay(this DateTime date)
    135. {
    136. return !date.IsHoliday() || !date.IsWeekend();
    137. }
    138. /// <summary>
    139. /// gibt den letzten Arbeitstag , ausgehend vom angegebenen Datum zurück unter Berücksichtigung des Wochenende und ev. Feiertagen
    140. /// </summary>
    141. /// <param name="date">das zu prüfende Datum</param>
    142. /// <returns></returns>
    143. public static DateTime GetLastWorkDay(this DateTime date)
    144. {
    145. switch (date.DayOfWeek)
    146. {
    147. case DayOfWeek.Saturday:
    148. {
    149. date = date.AddDays(-1);
    150. break;
    151. }
    153. case DayOfWeek.Sunday:
    154. {
    155. date = date.AddDays(-2);
    156. break;
    157. }
    159. default:
    160. {
    161. if (date.IsHoliday())
    162. date = GetLastWorkDay(date.AddDays(-1));
    163. break;
    164. }
    165. }
    166. return date;
    167. }
    169. #endregion
    171. #region Holiday Methods
    173. /// <summary>
    174. /// gibt alle Feiertage des Jahres des angegebenen Datums zurück und berücksichtigt das Bundesland.
    175. /// </summary>
    176. /// <param name="date">das Datum</param>
    177. /// <param name="state">Bundesland, für das der Feiertag geprüft werden soll</param>
    178. /// <returns></returns>
    179. public static List<DateTime> GetHolidays(this DateTime date, FederalStateEnum state)
    180. {
    181. var result = new List<DateTime>();
    182. switch (state)
    183. {
    184. case FederalStateEnum.SachsenAnhalt:
    185. result.Add(new DateTime(date.Year, 1, 6)); //Heilige Drei Könige
    186. break;
    187. case FederalStateEnum.BadenWürtenberg:
    188. case FederalStateEnum.Bayern:
    189. result.Add(new DateTime(date.Year, 1, 6)); //Heilige Drei Könige
    190. goto case FederalStateEnum.RheinlandPfalz;
    191. case FederalStateEnum.Saarland:
    192. result.Add(new DateTime(date.Year, 8, 15)); //Mariä Himmelfahrt
    193. goto case FederalStateEnum.RheinlandPfalz;
    194. case FederalStateEnum.NordrheinWestfalen:
    195. case FederalStateEnum.RheinlandPfalz:
    196. result.Add(new DateTime(date.Year, 11, 1)); //Allerheiligen
    197. break;
    198. }
    200. //alle Bundesländer
    201. result.Add(new DateTime(date.Year, 1, 1)); //Neujahr
    202. result.Add(new DateTime(date.Year, 5, 1)); //Tag der Arbeit
    203. result.Add(new DateTime(date.Year, 10, 3)); //Tag der dt. Einheit
    204. result.Add(new DateTime(date.Year, 12, 25)); //1. Weihnachtstag
    205. result.Add(new DateTime(date.Year, 12, 26)); //2. Weihnachtstag
    207. // Ostersonntag holen
    208. DateTime osterSonntag = GetEaster(date.Year);
    210. result.Add(osterSonntag); //Ostersonntag
    211. result.Add(osterSonntag.AddDays(1)); //Ostermontag
    212. result.Add(osterSonntag.AddDays(-2)); //Karfreitag
    213. result.Add(osterSonntag.AddDays(39)); //Christi Himmelfahrt
    214. result.Add(osterSonntag.AddDays(49)); //Pfingstsonntag
    215. result.Add(osterSonntag.AddDays(50)); //Pfingstmontag
    217. if (state == FederalStateEnum.BadenWürtenberg || state == FederalStateEnum.Bayern || state == FederalStateEnum.Hessen
    218. || state == FederalStateEnum.NordrheinWestfalen || state == FederalStateEnum.RheinlandPfalz
    219. || state == FederalStateEnum.Saarland)
    220. {
    221. result.Add(osterSonntag.AddDays(60)); //Fronleichnam
    222. }
    224. return result;
    225. }
    227. /// <summary>
    228. /// gibt den Ostersonntag des angegebenen Jahres
    229. /// </summary>
    230. /// <param name="year">das Jahr</param>
    231. /// <returns></returns>
    232. private static DateTime GetEaster(int year)
    233. {
    234. int a = year % 19;
    235. int b = year / 100;
    236. int c = (8 * b + 13) / 25 - 2;
    237. int d = b - (year / 400) - 2;
    238. int e = (19 * (year % 19) + ((15 - c + d) % 30)) % 30;
    239. if (e == 28)
    240. {
    241. if (a > 10)
    242. e = 27;
    243. }
    244. else if (e == 29)
    245. e = 28;
    246. int f = (d + 6 * e + 2 * (year % 4) + 4 * (year % 7) + 6) % 7;
    247. return new DateTime(year, 3, 22).AddDays(e + f);
    248. }
    250. #endregion
    252. #region Federal States Enum
    253. /// <summary>
    254. /// Auflistung der Bundesländer in Deutschland
    255. /// </summary>
    256. public enum FederalStateEnum
    257. {
    258. Invariant,
    260. BadenWürtenberg,
    261. Bayern,
    262. Berlin,
    263. Brandenburg,
    264. Bremen,
    265. Hamburg,
    266. Hessen,
    267. MecklenburgVorpommern,
    268. Niedersachsen,
    269. NordrheinWestfalen,
    270. RheinlandPfalz,
    271. Saarland,
    272. Sachsen,
    273. SachsenAnhalt,
    274. SchleswigHolstein,
    275. Thüringen
    276. }
    277. #endregion
    278. }
    279. }
    "Hier könnte Ihre Werbung stehen..."

Facebook
Telefonspende