C# Sonnenaufgang/Sonnenuntergang mit Breiten-/Längengraden

Question

Gibt es einen Weg in C#, um einen Breiten- und Längengrad zu berechnen, wenn die Sonne für einen bestimmten Tag aufgeht und aufgeht?

Answer 1

Javascript-Berechnungen here. Jetzt müssen Sie nur noch portieren.

---

Edit: die Berechnungen sind in den Quellcode this page jetzt.

---

Edit: here ist ein direkter Link zum Quellcode. Keine Notwendigkeit, durch das HTML zu jagen.

Answer 2

Beginnen Sie mit dieser Info:

Sunrise_equation

Ich verwende diese zu wright einen Ruby-Skript, das noch im Entstehen begriffen ist. Ich habe Probleme, die mehrteiligen julianischen Daten zu verstehen.

Eine Sache, die klar ist, ist, dass Sie für die genaue Solarlaufzeit gehen sollten. Dann subtrahieren und fügen Sie die semi_diurnal_arc = acos (cos_omega), die basiert auf Ihrem Breitengrad und der Deklination der Sonne. Oh! Und achten Sie darauf, Sonnen- Mittel- und Erdbrechung einzuschließen. Es scheint, dass diese Erde ein Zauberer ist.

Answer 3

Sie benötigen eine Formel, die die Zeitgleichung für die exzentrische Umlaufbahn des Erdmondsystems um die Sonne enthält. Sie müssen Koordinaten mit geeigneten Bezugspunkten wie WGS84 oder NAD27 oder etwas in der Art verwenden. Sie müssen den JULIAN-Kalender verwenden und nicht den, den wir täglich verwenden, um diese Zeiten zu bekommen. Es ist nicht leicht in einer Sekunde zu erraten. Ich möchte die Zeit an meinem Standort haben, an der die Schattenlänge der Höhe entspricht. Dies sollte zweimal pro Tag geschehen, wenn die Sonne 60 Grad über dem Horizont vor und nach dem Mittag angehoben wird. Außerdem, soweit ich verstehe, müssen Sie nur genau einen Tag pro Jahr hinzufügen, um siderische Zeit zu bekommen, also, wenn Sie Ihre Taktfrequenz X 366.25/365.25 erhöhen möchten, könnten Sie jetzt eine siderische Uhr anstelle einer bürgerlichen Uhr haben ??? "MATH ist die Sprache, in der jemand mächtig das Universum geschrieben hat"

Answer 4

Eine andere gute JS-Implementierung ist suncalc.

Die Anzahl der Codezeilen ist überschaubar, so dass eine Portierung auf andere Sprachen (C#) durchaus möglich ist.

Answer 5

Ich habe einen schnellen Python-Skript gemacht zu tun, dass: SunriseSunsetCalculator

Ich habe es noch innerhalb einer Klasse zu wickeln, aber es kann für andere nützlich sein.

---

Edit: Open Source ist fantastisch, da das grundlegende Skript zu begehen, jemand, der es in einem Modul eingewickelt und ein anderer eine cli Schnittstelle hinzugefügt! Danke an mbideau und nfischer für ihre Beiträge!

Answer 6

Ich habe NAA Javascript und C# verwendet, um diese Bibliothek in C# zu erstellen.

Sunrise and Sunset in C#

Getestet habe ich es gegen diese beiden Standorte, und es zeigt die Zeit genau wie die Seiten tun.

http://www.timeanddate.com/sun/usa/seattle

http://www.esrl.noaa.gov/gmd/grad/solcalc/

Answer 7

Die akzeptierte Antwort dafür war eine JavaScript-Implementierung, die, weil ich die Berechnung in C# tun musste nicht meine Anwendung passen.

Ich habe diesen C# Code verwendet: http://wiki.crowe.co.nz/Calculate%20Sunrise%2fSunset.ashx, den ich gegen die Sonnenauf-/Sonnenuntergang Zeiten hier validiert habe: http://www.timeanddate.com/astronomy/.

Wenn ich Sekunden auf die nächste Minute rufe, stimmen die Sonnenaufgangs- und Sonnenuntergangszeiten der C# -Implementierung mit den entsprechenden auf timeanddate.com angezeigten Werten überein, einschließlich der Fälle von Sommerzeit. Der Code ist allerdings ein wenig überwältigend (außer du würdest auch gerne Mondphasen-Daten haben), also werde ich es refactoring machen, um genau das zu tun, was ich jetzt benötige, die Zahlen sind korrekt.

Answer 8

Wenn Sie einen externen Service bevorzugen Sie diesen schönen und frei von Sonnenaufgang und Sonnenuntergang API verwenden: http://sunrise-sunset.org/api

ich es für mehrere Projekte verwendet habe und es funktioniert sehr gut, scheinen Daten sehr genau zu sein. Tun Sie einfach eine HTTP-GET-Anforderung an http://api.sunrise-sunset.org/json

Accepted Parameter:

• lat: Breite in Dezimalgrad. Erforderlich.
• lng: Längengrad in Dezimalgrad. Erforderlich.
• Datum: Datum im JJJJ-MM-TT-Format. Akzeptiert auch andere Datumsformate und sogar relative Datumsformate. Wenn nicht vorhanden, wird als Datum das aktuelle Datum verwendet. Wahlweise.
• Rückruf: Callback-Funktionsname für JSONP-Antwort. Wahlweise.
• formatiert: 0 oder 1 (1 ist Standard). Zeitwerte in Antwort werden nach ISO 8601 ausgedrückt und Tag_Länge wird in Sekunden ausgedrückt. Wahlweise.

Die Antwort umfasst Sonnenauf- und untergangszeiten sowie Dämmerungszeiten.

Answer 9

Diese API scheint für mich zu arbeiten:

http://sunrise-sunset.org/api

Answer 10

VB.Net Version von dotsa Antwort, die auch automatisch Zeitzonen bestimmen kann.

Ausgang (geprüft von den Sonnenuntergang an diesem Abend zu beobachten):

Main.VB:

Module Main 

Sub Main() 

    ' http://www.timeanddate.com/sun/usa/seattle 
    ' http://www.esrl.noaa.gov/gmd/grad/solcalc/ 

    ' Vessy, Switzerland 
    Dim latitude As Double = 46.17062 
    Dim longitude As Double = 6.161667 
    Dim dst As Boolean = True 
    Dim timehere As DateTime = DateTime.Now 

    Console.WriteLine("It is currently {0:HH:mm:ss} UTC", DateTime.UtcNow) 
    Console.WriteLine("The time here, at {0}°,{1}° is {2:HH:mm:ss}", latitude, longitude, timehere) 
    Dim local As TimeZoneInfo = TimeZoneInfo.Local 
    Dim zone As Integer = local.BaseUtcOffset().TotalHours 

    If local.SupportsDaylightSavingTime Then 
     Dim standard As String = local.StandardName 
     Dim daylight As String = local.DaylightName 
     dst = local.IsDaylightSavingTime(timehere) 
     Dim current As String = IIf(dst, daylight, standard) 
     Console.WriteLine("Daylight-saving time is supported here. Current offset {0:+0} hours, {1}", zone, current) 
    Else 
     Console.WriteLine("Daylight-saving time is not supported here") 
    End If 

    System.Console.WriteLine("Sunrise today {0}", Sunrises(latitude, longitude)) 
    System.Console.WriteLine("Sunset today {0}", Sunsets(latitude, longitude)) 
    System.Console.ReadLine() 
End Sub 

End Module 

Sun.vb:

Public Module Sun 
' Get sunrise time at latitude, longitude using local system timezone 
Function Sunrises(latitude As Double, longitude As Double) As DateTime 
    Dim julian As Double = JulianDay(DateTime.Now) 
    Dim rises As Double = SunRiseUTC(julian, latitude, longitude) 
    Dim timehere As DateTime = DateTime.Now 
    Dim local As TimeZoneInfo = TimeZoneInfo.Local 
    Dim dst As Boolean = local.IsDaylightSavingTime(timehere) 
    Dim zone As Integer = local.BaseUtcOffset().TotalHours 
    Dim result As DateTime = getDateTime(rises, zone, timehere, dst) 
    Return result 
End Function 
' Get sunset time at latitude, longitude using local system timezone 
Function Sunsets(latitude As Double, longitude As Double) As DateTime 
    Dim julian As Double = JulianDay(DateTime.Now) 
    Dim rises As Double = SunSetUTC(julian, latitude, longitude) 
    Dim timehere As DateTime = DateTime.Now 
    Dim local As TimeZoneInfo = TimeZoneInfo.Local 
    Dim dst As Boolean = local.IsDaylightSavingTime(timehere) 
    Dim zone As Integer = local.BaseUtcOffset().TotalHours 
    Dim result As DateTime = getDateTime(rises, zone, timehere, dst) 
    Return result 
End Function 
' Convert radian angle to degrees 
Public Function Degrees(angleRad As Double) As Double 
    Return (180.0 * angleRad/Math.PI) 
End Function 
' Convert degree angle to radians 
Public Function Radians(angleDeg As Double) As Double 
    Return (Math.PI * angleDeg/180.0) 
End Function 
'* Name: JulianDay 
'* Type: Function 
'* Purpose: Julian day from calendar day  
'* Arguments: 
'* year : 4 digit year 
'* month: January = 1 
'* day : 1 - 31 
'* Return value:  
'* The Julian day corresponding to the date 
'* Note:  
'* Number is returned for start of day. Fractional days should be 
'* added later. 
Public Function JulianDay(year As Integer, month As Integer, day As Integer) As Double 
    If month <= 2 Then 
     year -= 1 
     month += 12 
    End If 
    Dim A As Double = Math.Floor(year/100.0) 
    Dim B As Double = 2 - A + Math.Floor(A/4) 

    Dim julian As Double = Math.Floor(365.25 * (year + 4716)) + Math.Floor(30.6001 * (month + 1)) + day + B - 1524.5 
    Return julian 
End Function 

Public Function JulianDay([date] As DateTime) As Double 
    Return JulianDay([date].Year, [date].Month, [date].Day) 
End Function 

'***********************************************************************/ 
'* Name: JulianCenturies  
'* Type: Function 
'* Purpose: convert Julian Day to centuries since J2000.0. 
'* Arguments: 
'* julian : the Julian Day to convert 
'* Return value:  
'* the T value corresponding to the Julian Day 
'***********************************************************************/ 

Public Function JulianCenturies(julian As Double) As Double 
    Dim T As Double = (julian - 2451545.0)/36525.0 
    Return T 
End Function 


'***********************************************************************/ 
'* Name: JulianDayFromJulianCentury 
'* Type: Function 
'* Purpose: convert centuries since J2000.0 to Julian Day. 
'* Arguments: 
'* t : number of Julian centuries since J2000.0 
'* Return value:  
'* the Julian Day corresponding to the t value 
'***********************************************************************/ 

Public Function JulianDayFromJulianCentury(t As Double) As Double 
    Dim julian As Double = t * 36525.0 + 2451545.0 
    Return julian 
End Function 


'***********************************************************************/ 
'* Name: calGeomMeanLongSun 
'* Type: Function 
'* Purpose: calculate the Geometric Mean Longitude of the Sun 
'* Arguments: 
'* t : number of Julian centuries since J2000.0 
'* Return value:  
'* the Geometric Mean Longitude of the Sun in degrees 
'***********************************************************************/ 

Public Function GemoetricMeanLongitude(t As Double) As Double 
    Dim L0 As Double = 280.46646 + t * (36000.76983 + 0.0003032 * t) 
    While L0 > 360.0 
     L0 -= 360.0 
    End While 
    While L0 < 0.0 
     L0 += 360.0 
    End While 
    Return L0 
    ' in degrees 
End Function 


'***********************************************************************/ 
'* Name: calGeomAnomalySun 
'* Type: Function 
'* Purpose: calculate the Geometric Mean Anomaly of the Sun 
'* Arguments: 
'* t : number of Julian centuries since J2000.0 
'* Return value:  
'* the Geometric Mean Anomaly of the Sun in degrees 
'***********************************************************************/ 

Public Function GemoetricMeanAnomaly(t As Double) As Double 
    Dim M As Double = 357.52911 + t * (35999.05029 - 0.0001537 * t) 
    Return M 
    ' in degrees 
End Function 

'***********************************************************************/ 
'* Name: EarthOrbitEccentricity 
'* Type: Function 
'* Purpose: calculate the eccentricity of earth's orbit 
'* Arguments: 
'* t : number of Julian centuries since J2000.0 
'* Return value:  
'* the unitless eccentricity  
'***********************************************************************/ 


Public Function EarthOrbitEccentricity(t As Double) As Double 
    Dim e As Double = 0.016708634 - t * (0.000042037 + 0.0000001267 * t) 
    Return e 
    ' unitless 
End Function 

'***********************************************************************/ 
'* Name: SunCentre 
'* Type: Function 
'* Purpose: calculate the equation of center for the sun  
'* Arguments: 
'* t : number of Julian centuries since J2000.0 
'* Return value:  
'* in degrees 
'***********************************************************************/ 


Public Function SunCentre(t As Double) As Double 
    Dim m As Double = GemoetricMeanAnomaly(t) 

    Dim mrad As Double = Radians(m) 
    Dim sinm As Double = Math.Sin(mrad) 
    Dim sin2m As Double = Math.Sin(mrad + mrad) 
    Dim sin3m As Double = Math.Sin(mrad + mrad + mrad) 

    Dim C As Double = sinm * (1.914602 - t * (0.004817 + 0.000014 * t)) + sin2m * (0.019993 - 0.000101 * t) + sin3m * 0.000289 
    Return C 
    ' in degrees 
End Function 

'***********************************************************************/ 
'* Name: SunTrueLongitude 
'* Type: Function 
'* Purpose: calculate the true longitude of the sun 
'* Arguments: 
'* t : number of Julian centuries since J2000.0 
'* Return value:  
'* sun's true longitude in degrees 
'***********************************************************************/ 


Public Function SunTrueLongitude(t As Double) As Double 
    Dim l0 As Double = GemoetricMeanLongitude(t) 
    Dim c As Double = SunCentre(t) 

    Dim O As Double = l0 + c 
    Return O 
    ' in degrees 
End Function 

'***********************************************************************/ 
'* Name: SunTrueAnomaly 
'* Type: Function 
'* Purpose: calculate the true anamoly of the sun 
'* Arguments: 
'* t : number of Julian centuries since J2000.0 
'* Return value:  
'* sun's true anamoly in degrees  
'***********************************************************************/ 

Public Function SunTrueAnomaly(t As Double) As Double 
    Dim m As Double = GemoetricMeanAnomaly(t) 
    Dim c As Double = SunCentre(t) 

    Dim v As Double = m + c 
    Return v 
    ' in degrees 
End Function 

'***********************************************************************/ 
'* Name: SunDistanceAU 
'* Type: Function 
'* Purpose: calculate the distance to the sun in AU 
'* Arguments: 
'* t : number of Julian centuries since J2000.0 
'* Return value:  
'* sun radius vector in AUs 
'***********************************************************************/ 

Public Function SunDistanceAU(t As Double) As Double 
    Dim v As Double = SunTrueAnomaly(t) 
    Dim e As Double = EarthOrbitEccentricity(t) 

    Dim R As Double = (1.000001018 * (1 - e * e))/(1 + e * Math.Cos(Radians(v))) 
    Return R 
    ' in AUs 
End Function 

'***********************************************************************/ 
'* Name: SunApparentLongitude 
'* Type: Function 
'* Purpose: calculate the apparent longitude of the sun 
'* Arguments: 
'* t : number of Julian centuries since J2000.0 
'* Return value:  
'* sun's apparent longitude in degrees 
'***********************************************************************/ 

Public Function SunApparentLongitude(t As Double) As Double 
    Dim o As Double = SunTrueLongitude(t) 

    Dim omega As Double = 125.04 - 1934.136 * t 
    Dim lambda As Double = o - 0.00569 - 0.00478 * Math.Sin(Radians(omega)) 
    Return lambda 
    ' in degrees 
End Function 

'***********************************************************************/ 
'* Name: MeanObliquityOfEcliptic  
'* Type: Function 
'* Purpose: calculate the mean obliquity of the ecliptic  
'* Arguments: 
'* t : number of Julian centuries since J2000.0 
'* Return value:  
'* mean obliquity in degrees  
'***********************************************************************/ 

Public Function MeanObliquityOfEcliptic(t As Double) As Double 
    Dim seconds As Double = 21.448 - t * (46.815 + t * (0.00059 - t * (0.001813))) 
    Dim e0 As Double = 23.0 + (26.0 + (seconds/60.0))/60.0 
    Return e0 
    ' in degrees 
End Function 

'***********************************************************************/ 
'* Name: calcObliquityCorrection  
'* Type: Function 
'* Purpose: calculate the corrected obliquity of the ecliptic 
'* Arguments: 
'* t : number of Julian centuries since J2000.0 
'* Return value:  
'* corrected obliquity in degrees 
'***********************************************************************/ 

Public Function calcObliquityCorrection(t As Double) As Double 
    Dim e0 As Double = MeanObliquityOfEcliptic(t) 

    Dim omega As Double = 125.04 - 1934.136 * t 
    Dim e As Double = e0 + 0.00256 * Math.Cos(Radians(omega)) 
    Return e 
    ' in degrees 
End Function 

'***********************************************************************/ 
'* Name: SunRightAscension 
'* Type: Function 
'* Purpose: calculate the right ascension of the sun  
'* Arguments: 
'* t : number of Julian centuries since J2000.0 
'* Return value:  
'* sun's right ascension in degrees 
'***********************************************************************/ 

Public Function SunRightAscension(t As Double) As Double 
    Dim e As Double = calcObliquityCorrection(t) 
    Dim lambda As Double = SunApparentLongitude(t) 

    Dim tananum As Double = (Math.Cos(Radians(e)) * Math.Sin(Radians(lambda))) 
    Dim tanadenom As Double = (Math.Cos(Radians(lambda))) 
    Dim alpha As Double = Degrees(Math.Atan2(tananum, tanadenom)) 
    Return alpha 
    ' in degrees 
End Function 

'***********************************************************************/ 
'* Name: SunDeclination 
'* Type: Function 
'* Purpose: calculate the declination of the sun  
'* Arguments: 
'* t : number of Julian centuries since J2000.0 
'* Return value:  
'* sun's declination in degrees 
'***********************************************************************/ 

Public Function SunDeclination(t As Double) As Double 
    Dim e As Double = calcObliquityCorrection(t) 
    Dim lambda As Double = SunApparentLongitude(t) 

    Dim sint As Double = Math.Sin(Radians(e)) * Math.Sin(Radians(lambda)) 
    Dim theta As Double = Degrees(Math.Asin(sint)) 
    Return theta 
    ' in degrees 
End Function 

'***********************************************************************/ 
'* Name: TrueSolarToMeanSolar 
'* Type: Function 
'* Purpose: calculate the difference between true solar time and mean 
'* solar time 
'* Arguments: 
'* t : number of Julian centuries since J2000.0 
'* Return value:  
'* equation of time in minutes of time 
'***********************************************************************/ 

Public Function TrueSolarToMeanSolar(t As Double) As Double 
    Dim epsilon As Double = calcObliquityCorrection(t) 
    Dim l0 As Double = GemoetricMeanLongitude(t) 
    Dim e As Double = EarthOrbitEccentricity(t) 
    Dim m As Double = GemoetricMeanAnomaly(t) 

    Dim y As Double = Math.Tan(Radians(epsilon)/2.0) 
    y *= y 

    Dim sin2l0 As Double = Math.Sin(2.0 * Radians(l0)) 
    Dim sinm As Double = Math.Sin(Radians(m)) 
    Dim cos2l0 As Double = Math.Cos(2.0 * Radians(l0)) 
    Dim sin4l0 As Double = Math.Sin(4.0 * Radians(l0)) 
    Dim sin2m As Double = Math.Sin(2.0 * Radians(m)) 

    Dim Etime As Double = y * sin2l0 - 2.0 * e * sinm + 4.0 * e * y * sinm * cos2l0 - 0.5 * y * y * sin4l0 - 1.25 * e * e * sin2m 

    Return Degrees(Etime) * 4.0 
    ' in minutes of time 
End Function 

'***********************************************************************/ 
'* Name: SunriseHourAngle 
'* Type: Function 
'* Purpose: calculate the hour angle of the sun at sunrise for the 
'* latitude 
'* Arguments: 
'* lat : latitude of observer in degrees  
'* solarDec : declination angle of sun in degrees 
'* Return value:  
'* hour angle of sunrise in radians 
'***********************************************************************/ 

Public Function SunriseHourAngle(lat As Double, solarDec As Double) As Double 
    Dim latRad As Double = Radians(lat) 
    Dim sdRad As Double = Radians(solarDec) 

    Dim HAarg As Double = (Math.Cos(Radians(90.833))/(Math.Cos(latRad) * Math.Cos(sdRad)) - Math.Tan(latRad) * Math.Tan(sdRad)) 

    Dim HA As Double = (Math.Acos(Math.Cos(Radians(90.833))/(Math.Cos(latRad) * Math.Cos(sdRad)) - Math.Tan(latRad) * Math.Tan(sdRad))) 

    Return HA 
    ' in radians 
End Function 

'***********************************************************************/ 
'* Name: SunsetHourAngle  
'* Type: Function 
'* Purpose: calculate the hour angle of the sun at sunset for the 
'* latitude 
'* Arguments: 
'* lat : latitude of observer in degrees  
'* solarDec : declination angle of sun in degrees 
'* Return value:  
'* hour angle of sunset in radians 
'***********************************************************************/ 

Public Function SunsetHourAngle(lat As Double, solarDec As Double) As Double 
    Dim latRad As Double = Radians(lat) 
    Dim sdRad As Double = Radians(solarDec) 

    Dim HAarg As Double = (Math.Cos(Radians(90.833))/(Math.Cos(latRad) * Math.Cos(sdRad)) - Math.Tan(latRad) * Math.Tan(sdRad)) 

    Dim HA As Double = (Math.Acos(Math.Cos(Radians(90.833))/(Math.Cos(latRad) * Math.Cos(sdRad)) - Math.Tan(latRad) * Math.Tan(sdRad))) 

    Return -HA 
    ' in radians 
End Function 


'***********************************************************************/ 
'* Name: SunRiseUTC 
'* Type: Function 
'* Purpose: calculate the Universal Coordinated Time (UTC) of sunrise 
'* for the given day at the given location on earth 
'* Arguments: 
'* julian : julian day 
'* latitude : latitude of observer in degrees 
'* longitude : longitude of observer in degrees 
'* Return value:  
'* time in minutes from zero Z 
'***********************************************************************/ 

'Public Function SunRiseUTC(julian As Double, latitude As Double, longitude As Double) As Double 
' Dim t As Double = JulianCenturies(julian) 

' ' *** Find the time of solar noon at the location, and use 
' ' that declination. This is better than start of the 
' ' Julian day 

' Dim noonmin As Double = SolarNoonUTC(t, longitude) 
' Dim tnoon As Double = JulianCenturies(julian + noonmin/1440.0) 

' ' *** First pass to approximate sunrise (using solar noon) 

' Dim eqTime As Double = TrueSolarToMeanSolar(tnoon) 
' Dim solarDec As Double = SunDeclination(tnoon) 
' Dim hourAngle As Double = SunriseHourAngle(latitude, solarDec) 

' Dim delta As Double = longitude - Degrees(hourAngle) 
' Dim timeDiff As Double = 4 * delta 
' ' in minutes of time 
' Dim timeUTC As Double = 720 + timeDiff - eqTime 
' ' in minutes 
' ' alert("eqTime = " + eqTime + "\nsolarDec = " + solarDec + "\ntimeUTC = " + timeUTC); 

' ' *** Second pass includes fractional julianay in gamma calc 

' Dim newt As Double = JulianCenturies(JulianDayFromJulianCentury(t) + timeUTC/1440.0) 
' eqTime = TrueSolarToMeanSolar(newt) 
' solarDec = SunDeclination(newt) 
' hourAngle = SunriseHourAngle(latitude, solarDec) 
' delta = longitude - Degrees(hourAngle) 
' timeDiff = 4 * delta 
' timeUTC = 720 + timeDiff - eqTime 
' ' in minutes 
' ' alert("eqTime = " + eqTime + "\nsolarDec = " + solarDec + "\ntimeUTC = " + timeUTC); 

' Return timeUTC 
'End Function 

'***********************************************************************/ 
'* Name: SolarNoonUTC 
'* Type: Function 
'* Purpose: calculate the Universal Coordinated Time (UTC) of solar 
'* noon for the given day at the given location on earth 
'* Arguments: 
'* t : number of Julian centuries since J2000.0 
'* longitude : longitude of observer in degrees 
'* Return value:  
'* time in minutes from zero Z 
'***********************************************************************/ 

Public Function SolarNoonUTC(t As Double, longitude As Double) As Double 
    ' First pass uses approximate solar noon to calculate eqtime 
    Dim tnoon As Double = JulianCenturies(JulianDayFromJulianCentury(t) + longitude/360.0) 
    Dim eqTime As Double = TrueSolarToMeanSolar(tnoon) 
    Dim solNoonUTC As Double = 720 + (longitude * 4) - eqTime 
    ' min 
    Dim newt As Double = JulianCenturies(JulianDayFromJulianCentury(t) - 0.5 + solNoonUTC/1440.0) 

    eqTime = TrueSolarToMeanSolar(newt) 
    ' double solarNoonDec = SunDeclination(newt); 
    solNoonUTC = 720 + (longitude * 4) - eqTime 
    ' min 
    Return solNoonUTC 
End Function 

'***********************************************************************/ 
'* Name: SunSetUTC 
'* Type: Function 
'* Purpose: calculate the Universal Coordinated Time (UTC) of sunset  
'* for the given day at the given location on earth 
'* Arguments: 
'* julian : julian day 
'* latitude : latitude of observer in degrees 
'* longitude : longitude of observer in degrees 
'* Return value:  
'* time in minutes from zero Z 
'***********************************************************************/ 

Public Function SunSetUTC(julian As Double, latitude As Double, longitude As Double) As Double 
    Dim t = JulianCenturies(julian) 
    Dim eqTime = TrueSolarToMeanSolar(t) 
    Dim solarDec = SunDeclination(t) 
    Dim hourAngle = SunriseHourAngle(latitude, solarDec) 
    hourAngle = -hourAngle 
    Dim delta = longitude + Degrees(hourAngle) 
    Dim timeUTC = 720 - (4.0 * delta) - eqTime 
    ' in minutes 
    Return timeUTC 
End Function 

Public Function SunRiseUTC(julian As Double, latitude As Double, longitude As Double) As Double 
    Dim t = JulianCenturies(julian) 
    Dim eqTime = TrueSolarToMeanSolar(t) 
    Dim solarDec = SunDeclination(t) 
    Dim hourAngle = SunriseHourAngle(latitude, solarDec) 
    Dim delta = longitude + Degrees(hourAngle) 
    Dim timeUTC = 720 - (4.0 * delta) - eqTime 
    ' in minutes 
    Return timeUTC 
End Function 

Public Function getTimeString(time As Double, timezone As Integer, julian As Double, dst As Boolean) As String 
    Dim timeLocal = time + (timezone * 60.0) 
    Dim riseT = JulianCenturies(julian + time/1440.0) 
    timeLocal += (If((dst), 60.0, 0.0)) 
    Return getTimeString(timeLocal) 
End Function 

Public Function getDateTime(time As Double, timezone As Integer, [date] As DateTime, dst As Boolean) As System.Nullable(Of DateTime) 
    Dim julian As Double = JulianDay([date]) 
    Dim timeLocal = time + (timezone * 60.0) 
    Dim riseT = JulianCenturies(julian + time/1440.0) 
    timeLocal += (If((dst), 60.0, 0.0)) 
    Return getDateTime(timeLocal, [date]) 
End Function 

Private Function getTimeString(minutes As Double) As String 

    Dim output As String = "" 

    If (minutes >= 0) AndAlso (minutes < 1440) Then 
     Dim floatHour = minutes/60.0 
     Dim hour = Math.Floor(floatHour) 
     Dim floatMinute = 60.0 * (floatHour - Math.Floor(floatHour)) 
     Dim minute = Math.Floor(floatMinute) 
     Dim floatSec = 60.0 * (floatMinute - Math.Floor(floatMinute)) 
     Dim second = Math.Floor(floatSec + 0.5) 
     If second > 59 Then 
      second = 0 
      minute += 1 
     End If 
     If (second >= 30) Then 
      minute += 1 
     End If 
     If minute > 59 Then 
      minute = 0 
      hour += 1 
     End If 
     output = [String].Format("{0:00}:{1:00}", hour, minute) 
    Else 
     Return "error" 
    End If 

    Return output 
End Function 

Private Function getDateTime(minutes As Double, [date] As DateTime) As System.Nullable(Of DateTime) 

    Dim retVal As System.Nullable(Of DateTime) = Nothing 

    If (minutes >= 0) AndAlso (minutes < 1440) Then 
     Dim floatHour = minutes/60.0 
     Dim hour = Math.Floor(floatHour) 
     Dim floatMinute = 60.0 * (floatHour - Math.Floor(floatHour)) 
     Dim minute = Math.Floor(floatMinute) 
     Dim floatSec = 60.0 * (floatMinute - Math.Floor(floatMinute)) 
     Dim second = Math.Floor(floatSec + 0.5) 
     If second > 59 Then 
      second = 0 
      minute += 1 
     End If 
     If (second >= 30) Then 
      minute += 1 
     End If 
     If minute > 59 Then 
      minute = 0 
      hour += 1 
     End If 
     Return New DateTime([date].Year, [date].Month, [date].Day, CInt(hour), CInt(minute), CInt(second)) 
    Else 
     Return retVal 
    End If 
End Function 
End Module 

Answer 11

Ja beenden ein paar .

Ein paar Links für Muster.

http://williams.best.vwh.net/sunrise_sunset_example.htm

http://www.codeproject.com/Articles/29306/C-Class-for-Calculating-Sunrise-and-Sunset-Times

https://social.msdn.microsoft.com/Forums/vstudio/en-US/a4fad4c3-6d18-41fc-82b7-1f3031349837/get-sunrise-and-sunset-time-based-on-latitude-and-longitude?forum=csharpgeneral

https://gist.github.com/cstrahan/767532

http://pointofint.blogspot.com/2014/06/sunrise-and-sunset-in-c.html

http://yaddb.blogspot.com/2013/01/how-to-calculate-sunrise-and-sunset.html

https://forums.asp.net/t/1810934.aspx?Sunrise+and+Sunset+timings+Calculation+

http://www.ip2location.com/tutorials/display-sunrise-sunset-time-using-csharp-and-mysql-database

http://en.pudn.com/downloads270/sourcecode/windows/csharp/detail1235934_en.html

http://regator.com/p/25716249/c_class_for_calculating_sunrise_and_sunset_times

http://forums.xkcd.com/viewtopic.php?t=102253

http://www.redrok.com/solar_position_algorithm.pdf

http://sidstation.loudet.org/sunazimuth-en.xhtml

https://sourceforge.net/directory/os:windows/?q=sunrise/set%20times

https://www.nuget.org/packages/SolarCalculator/

http://www.grasshopper3d.com/forum/topics/solar-calculation-plugin

und dies war ein Projekt, das ich für Planeten Source Code habe vor langer Zeit, aber zum Glück gerettet ich es an anderer Stelle, weil diese Website Daten verloren.

https://github.com/DouglasAllen/SunTimes.VSCS.Net

verwendet diesen Gist und

https://gist.github.com/DouglasAllen/c682e4c412a0b9d8f536b014c1766f20

nun für eine kurze Erläuterung der Technik, das zu tun.

Zuerst für jeden Tag brauchen Sie echte solar Mittag oder Transit für Ihren Standort.

Dies berücksichtigt Ihre lokale Länge. Es kann in eine Zeit umgewandelt werden, indem Sie es durch 15 teilen.

Das ist, wie viel Zeit später Sie von Zulu Zone Zeit oder Null Länge sind.

Das beginnt um 12:00 Uhr oder Mittag.

Und auf Ihre Zeit aus dem Längengrad berechnet.

Jetzt der schwierige Teil. Sie benötigen einen Weg, um die Zeitgleichung zu berechnen.

Das ist ein Zeitunterschied, verursacht durch Erdneigung und Umlaufbahn um die Sonne.

Diese Ihnen eine Idee geben ... https://en.wikipedia.org/wiki/Equation_of_time

Aber sie haben eine Formel, die viel einfacher ist ....https://en.wikipedia.org/wiki/Sunrise_equation

Dieser Typ hat einige Bücher, die viele Leute kaufen gehen. :-D https://en.wikipedia.org/wiki/Jean_Meeus

Verwenden Sie Ihre erste Berechnung für die mittlere Sonnentransit und berechnen einen JDN ... https://en.wikipedia.org/wiki/Julian_day

Dies wird durch alle Winkel Formeln als eine Zeit, in Julian Jahrhundert https://en.wikipedia.org/wiki/Julian_year_(astronomy)

verwendet wird

https://en.wikipedia.org/wiki/Epoch_(astronomy)

Es ist im Grunde Ihre JDN minus der Epoche wie J2000 oder 2.451.545,0 alle geteilt durch 36.525,0 Sie das Julian Jahrhundert geben oder t , die für die meisten Formeln verwendet wird, die t als Parameter haben. Manchmal wird Julian Millennia verwendet. In diesem Fall ist es 3652500.0

Der Trick ist, jene Winkelformeln zu finden, die Ihnen helfen, die Gleichung der Zeit zu lösen.

Dann erhalten Sie Ihren echten Solartransit und subtrahieren Sie den halben Tag oder fügen Sie den halben Tag des Sonnenlichts für Ihren Standort hinzu. Sie werden diese in den Antworten und der Software finden.

Sobald Sie etwas gehen, können Sie es gegen eine Suche nach den Zeiten oder Online-Rechner überprüfen.

Ich hoffe, das ist genug, um Sie in Gang zu bringen. Es gibt überall Bibliotheken, aber es ist nicht so schwer, es selbst zu machen. Ich tat es aber in Ruby. Es könnte sich als nützlich erweisen. https://github.com/DouglasAllen/gem-equationoftime

viel glück!

Answer 12

Ich weiß, dass dieser Beitrag ist alt, aber falls jemand noch sucht ...

CoordinateSharp als Nuget Paket zur Verfügung steht. Es ist ein eigenständiges Paket, das Sonne und Mondzeiten verarbeiten kann. Es ist innerhalb weniger Minuten genau.

Celestial cel = Celestial.CalculateCelestialTimes(85.57682, -70.75678, new DateTime(2017,8,21)); 
Console.WriteLine(cel.SunRise.Value.ToString()); 

Hinweis:

Es geht davon aus Datetime sind immer in UTC.

Zuletzt müssen Sie möglicherweise auf die Himmelsobjekte Sonne/Mond .Condition verweisen, wenn ein Datum null zurückgibt. Dies geschieht, wenn die Sonne den ganzen Tag auf und ab geht.

Answer 13

Ich habe dieses Nuget-Paket in UWP getestet.

https://www.nuget.org/packages/SolarCalculator/

Die Dokumentation ein wenig lückenhaft ist, und ist hier:

https://github.com/porrey/Solar-Calculator

du den Sonnenaufgang bekommen verwenden können,

la = Breite gegeben; und lo = Länge; für Ihre Region:

  SolarTimes solarTimes = new SolarTimes(DateTime.Now, la, lo); 
      DateTime sr = solarTimes.Sunrise; 
      DateTime dt = Convert.ToDateTime(sr); 
      textblockb.Text = dt.ToString("h:mm:ss"); 

Sie können es in Visual Studio mit dem

Install-Package SolarCalculator -Version 2.0.2 

oder durch Nachschlagen SolarCalculator im "Manage NuGet Packages" Visual Studio Library Manager PM installieren.